package.xml0000644000076500000240000227001213614652362013073 0ustar gsherwoodstaff PHP_CodeSniffer pear.php.net PHP_CodeSniffer tokenizes PHP, JavaScript and CSS files to detect and fix violations of a defined set of coding standards. PHP_CodeSniffer is a set of two PHP scripts; the main phpcs script that tokenizes PHP, JavaScript and CSS files to detect violations of a defined coding standard, and a second phpcbf script to automatically correct coding standard violations. PHP_CodeSniffer is an essential development tool that ensures your code remains clean and consistent. Greg Sherwood squiz gsherwood@squiz.net yes 2020-01-30 3.5.4 3.5.4 stable stable BSD 3-Clause License - The PHP 7.4 numeric separator backfill now works correctly for more float formats -- Thanks to Juliette Reinders Folmer for the patch - The PHP 7.4 numeric separator backfill is no longer run on PHP version 7.4.0 or greater - File::getCondition() now accepts a 3rd argument that allows for the closest matching token to be returned -- By default, it continues to return the first matched token found from the top of the file - Fixed detection of array return types for arrow functions - Added Generic.PHP.DisallowRequestSuperglobal to ban the use of the $_REQUEST superglobal -- Thanks to Morerice for the contribution - Generic.ControlStructures.InlineControlStructure no longer shows errors for WHILE and FOR statements without a body -- Previously it required these to have curly braces, but there were no statements to enclose in them -- Thanks to Juliette Reinders Folmer for the patch - PSR12.ControlStructures.BooleanOperatorPlacement can now be configured to enforce a specific operator position -- By default, the sniff ensures that operators are all at the begining or end of lines, but not a mix of both -- Set the allowOnly property to "first" to enforce all boolean operators to be at the start of a line -- Set the allowOnly property to "last" to enforce all boolean operators to be at the end of a line -- Thanks to Vincent Langlet for the patch - PSR12.Files.ImportStatement now auto-fixes import statements by removing the leading slash -- Thanks to Michał Bundyra for the patch - Squiz.ControlStructures.ForLoopDeclaration now has a setting to ignore newline characters -- Default remains FALSE, so newlines are not allowed within FOR definitions -- Override the "ignoreNewlines" setting in a ruleset.xml file to change - Squiz.PHP.InnerFunctions now handles multiple nested anon classes correctly - Fixed bug #2497 : Sniff properties not set when referencing a sniff using relative paths or non-native slashes -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2657 : Squiz.WhiteSpace.FunctionSpacing can remove spaces between comment and first/last method during auto-fixing -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2688 : Case statements not tokenized correctly when switch is contained within ternary - Fixed bug #2698 : PHPCS throws errors determining auto report width when shell_exec is disabled -- Thanks to Matthew Peveler for the patch - Fixed bug #2730 : PSR12.ControlStructures.ControlStructureSpacing does not ignore comments between conditions -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2732 : PSR12.Files.FileHeader misidentifies file header in mixed content file - Fixed bug #2745 : AbstractArraySniff wrong indices when mixed coalesce and ternary values -- Thanks to Michał Bundyra for the patch - Fixed bug #2748 : Wrong end of statement for fn closures -- Thanks to Michał Bundyra for the patch - Fixed bug #2751 : Autoload relative paths first to avoid confusion with files from the global include path -- Thanks to Klaus Purer for the patch - Fixed bug #2763 : PSR12 standard reports errors for multi-line FOR definitions - Fixed bug #2768 : Generic.Files.LineLength false positive for non-breakable strings at exactly the soft limit -- Thanks to Alex Miles for the patch - Fixed bug #2773 : PSR2.Methods.FunctionCallSignature false positive when arrow function has array return type - Fixed bug #2790 : PSR12.Traits.UseDeclaration ignores block comments -- Thanks to Vincent Langlet for the patch - Fixed bug #2791 : PSR12.Functions.NullableTypeDeclaration false positive when ternary operator used with instanceof -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2802 : Can't specify a report file path using the tilde shortcut - Fixed bug #2804 : PHP4-style typed properties not tokenized correctly -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2805 : Undefined Offset notice during live coding of arrow functions -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2843 : Tokenizer does not support alternative syntax for declare statements -- Thanks to Juliette Reinders Folmer for the patch 5.4.0 1.4.0b1 tokenizer xmlwriter simplexml windows 3.5.4 3.5.4 stable stable 2020-01-31 BSD License - The PHP 7.4 numeric separator backfill now works correctly for more float formats -- Thanks to Juliette Reinders Folmer for the patch - The PHP 7.4 numeric separator backfill is no longer run on PHP version 7.4.0 or greater - File::getCondition() now accepts a 3rd argument that allows for the closest matching token to be returned -- By default, it continues to return the first matched token found from the top of the file - Fixed detection of array return types for arrow functions - Added Generic.PHP.DisallowRequestSuperglobal to ban the use of the $_REQUEST superglobal -- Thanks to Morerice for the contribution - Generic.ControlStructures.InlineControlStructure no longer shows errors for WHILE and FOR statements without a body -- Previously it required these to have curly braces, but there were no statements to enclose in them -- Thanks to Juliette Reinders Folmer for the patch - PSR12.ControlStructures.BooleanOperatorPlacement can now be configured to enforce a specific operator position -- By default, the sniff ensures that operators are all at the begining or end of lines, but not a mix of both -- Set the allowOnly property to "first" to enforce all boolean operators to be at the start of a line -- Set the allowOnly property to "last" to enforce all boolean operators to be at the end of a line -- Thanks to Vincent Langlet for the patch - PSR12.Files.ImportStatement now auto-fixes import statements by removing the leading slash -- Thanks to Michał Bundyra for the patch - Squiz.ControlStructures.ForLoopDeclaration now has a setting to ignore newline characters -- Default remains FALSE, so newlines are not allowed within FOR definitions -- Override the "ignoreNewlines" setting in a ruleset.xml file to change - Squiz.PHP.InnerFunctions now handles multiple nested anon classes correctly - Fixed bug #2497 : Sniff properties not set when referencing a sniff using relative paths or non-native slashes -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2657 : Squiz.WhiteSpace.FunctionSpacing can remove spaces between comment and first/last method during auto-fixing -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2688 : Case statements not tokenized correctly when switch is contained within ternary - Fixed bug #2698 : PHPCS throws errors determining auto report width when shell_exec is disabled -- Thanks to Matthew Peveler for the patch - Fixed bug #2730 : PSR12.ControlStructures.ControlStructureSpacing does not ignore comments between conditions -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2732 : PSR12.Files.FileHeader misidentifies file header in mixed content file - Fixed bug #2745 : AbstractArraySniff wrong indices when mixed coalesce and ternary values -- Thanks to Michał Bundyra for the patch - Fixed bug #2748 : Wrong end of statement for fn closures -- Thanks to Michał Bundyra for the patch - Fixed bug #2751 : Autoload relative paths first to avoid confusion with files from the global include path -- Thanks to Klaus Purer for the patch - Fixed bug #2763 : PSR12 standard reports errors for multi-line FOR definitions - Fixed bug #2768 : Generic.Files.LineLength false positive for non-breakable strings at exactly the soft limit -- Thanks to Alex Miles for the patch - Fixed bug #2773 : PSR2.Methods.FunctionCallSignature false positive when arrow function has array return type - Fixed bug #2790 : PSR12.Traits.UseDeclaration ignores block comments -- Thanks to Vincent Langlet for the patch - Fixed bug #2791 : PSR12.Functions.NullableTypeDeclaration false positive when ternary operator used with instanceof -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2802 : Can't specify a report file path using the tilde shortcut - Fixed bug #2804 : PHP4-style typed properties not tokenized correctly -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2805 : Undefined Offset notice during live coding of arrow functions -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2843 : Tokenizer does not support alternative syntax for declare statements -- Thanks to Juliette Reinders Folmer for the patch 3.5.3 3.5.3 stable stable 2019-12-04 BSD License - The PHP 7.4 T_FN token has been made available for older versions -- T_FN represents the fn string used for arrow functions -- The double arrow becomes the scope opener, and uses a new T_FN_ARROW token type -- The token after the statement (normally a semicolon) becomes the scope closer -- The token is also associated with the opening and closing parenthesis of the statement -- Any functions named "fn" will cause have a T_FN token for the function name, but have no scope information -- Thanks to Michał Bundyra for the help with this change - PHP 7.4 numeric separators are now tokenized in the same way when using older PHP versions -- Previously, a number like 1_000 would tokenize as T_LNUMBER (1), T_STRING (_000) -- Now, the number tokenizes as T_LNUMBER (1_000) -- Sniff developers should consider how numbers with underscores impact their custom sniffs - The PHPCS file cache now takes file permissions into account -- The cache is now invalidated for a file when its permissions are changed - File::getMethodParameters() now supports arrow functions - File::getMethodProperties() now supports arrow functions - Added Fixer::changeCodeBlockIndent() to change the indent of a code block while auto-fixing -- Can be used to either increase or decrease the indent -- Useful when moving the start position of something like a closure, where you want the content to also move - Added Generic.Files.ExecutableFile sniff -- Ensures that files are not executable -- Thanks to Matthew Peveler for the contribution - Generic.CodeAnalysis.EmptyPhpStatement now reports unnecessary semicolons after control structure closing braces -- Thanks to Vincent Langlet for the patch - Generic.PHP.LowerCaseKeyword now enforces that the "fn" keyword is lowercase -- Thanks to Michał Bundyra for the patch - Generic.WhiteSpace.ScopeIndent now supports static arrow functions - PEAR.Functions.FunctionCallSignature now adjusts the indent of function argument contents during auto-fixing -- Previously, only the first line of an argument was changed, leading to inconsistent indents -- This change also applies to PSR2.Methods.FunctionCallSignature - PSR2.ControlStructures.ControlStructureSpacing now checks whitespace before the closing parenthesis of multi-line control structures -- Previously, it incorrectly applied the whitespace check for single-line definitions only - PSR12.Functions.ReturnTypeDeclaration now checks the return type of arrow functions -- Thanks to Michał Bundyra for the patch - PSR12.Traits.UseDeclaration now ensures all trait import statements are grouped together -- Previously, the trait import section of the class ended when the first non-import statement was found -- Checking now continues throughout the class to ensure all statements are grouped together -- This also ensures that empty lines are not requested after an import statement that isn't the last one - Squiz.Functions.LowercaseFunctionKeywords now enforces that the "fn" keyword is lowercase -- Thanks to Michał Bundyra for the patch - Fixed bug #2586 : Generic.WhiteSpace.ScopeIndent false positives when indenting open tags at a non tab-stop - Fixed bug #2638 : Squiz.CSS.DuplicateClassDefinitionSniff sees comments as part of the class name -- Thanks to Raphael Horber for the patch - Fixed bug #2640 : Squiz.WhiteSpace.OperatorSpacing false positives for some negation operators -- Thanks to Jakub Chábek and Juliette Reinders Folmer for the patch - Fixed bug #2674 : Squiz.Functions.FunctionDeclarationArgumentSpacing prints wrong argument name in error message - Fixed bug #2676 : PSR12.Files.FileHeader locks up when file ends with multiple inline comments - Fixed bug #2678 : PSR12.Classes.AnonClassDeclaration incorrectly enforcing that closing brace be on a line by itself - Fixed bug #2685 : File::getMethodParameters() setting typeHintEndToken for vars with no type hint -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2694 : AbstractArraySniff produces invalid indices when using ternary operator -- Thanks to Michał Bundyra for the patch - Fixed bug #2702 : Generic.WhiteSpace.ScopeIndent false positive when using ternary operator with short arrays 3.5.2 3.5.2 stable stable 2019-10-28 BSD License - Generic.ControlStructures.DisallowYodaConditions now returns less false positives -- False positives were being returned for array comparisions, or when performing some function calls - Squiz.WhiteSpace.SemicolonSpacing.Incorrect error message now escapes newlines and tabs -- Provides a clearer error message as whitespace is now visible -- Also allows for better output for report types such as CSV and XML - The error message for PSR12.Files.FileHeader.SpacingAfterBlock has been made clearer -- It now uses the wording from the published PSR-12 standard to indicate that blocks must be separated by a blank line -- Thanks to Craig Duncan for the patch - Fixed bug #2654 : Incorrect indentation for arguments of multiline function calls - Fixed bug #2656 : Squiz.WhiteSpace.MemberVarSpacing removes comments before first member var during auto fixing -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2663 : Generic.NamingConventions.ConstructorName complains about old constructor in interfaces - Fixed bug #2664 : PSR12.Files.OpenTag incorrectly identifies PHP file with only an opening tag - Fixed bug #2665 : PSR12.Files.ImportStatement should not apply to traits - Fixed bug #2673 : PSR12.Traits.UseDeclaration does not allow comments or blank lines between use statements 3.5.1 3.5.1 stable stable 2019-10-17 BSD License - Very very verbose diff report output has slightly changed to improve readability -- Output is printed when running PHPCS with the --report=diff and -vvv command line arguments -- Fully qualified class names have been replaced with sniff codes -- Tokens being changed now display the line number they are on - PSR2, PSR12, and PEAR standards now correctly check for blank lines at the start of function calls -- This check has been missing from these standards, but has now been implemented -- When using the PEAR standard, the error code is PEAR.Functions.FunctionCallSignature.FirstArgumentPosition -- When using PSR2 or PSR12, the error code is PSR2.Methods.FunctionCallSignature.FirstArgumentPosition - PSR12.ControlStructures.BooleanOperatorPlacement no longer complains when multiple expression appears on the same line -- Previously, boolean operators were enforce to appear at the start or end of lines only -- Boolean operators can now appear in the middle of the line - PSR12.Files.FileHeader no longer ignores comments preceding a use, namespace, or declare statement - PSR12.Files.FileHeader now allows a hashbang line at the top of the file - Fixed bug #2506 : PSR2 standard can't auto fix multi-line function call inside a string concat statement - Fixed bug #2530 : PEAR.Commenting.FunctionComment does not support intersection types in comments - Fixed bug #2615 : Constant visibility false positive on non-class constants - Fixed bug #2616 : PSR12.Files.FileHeader false positive when file only contains docblock - Fixed bug #2619 : PSR12.Files.FileHeader locks up when inline comment is the last content in a file - Fixed bug #2621 : PSR12.Classes.AnonClassDeclaration.CloseBraceSameLine false positive for anon class passed as function argument -- Thanks to Martins Sipenko for the patch - Fixed bug #2623 : PSR12.ControlStructures.ControlStructureSpacing not ignoring indentation inside multi-line string arguments - Fixed bug #2624 : PSR12.Traits.UseDeclaration doesnt apply the correct indent during auto fixing - Fixed bug #2626 : PSR12.Files.FileHeader detects @var annotations as file docblocks - Fixed bug #2628 : PSR12.Traits.UseDeclaration does not allow comments above a USE declaration - Fixed bug #2632 : Incorrect indentation of lines starting with "static" inside closures - Fixed bug #2641 : PSR12.Functions.NullableTypeDeclaration false positive when using new static() 3.5.0 3.5.0 stable stable 2019-09-27 BSD License - The included PSR12 standard is now complete and ready to use -- Check your code using PSR-12 by running PHPCS with --standard=PSR12 - Added support for PHP 7.4 typed properties -- The nullable operator is now tokenized as T_NULLABLE inside property types, as it is elsewhere -- To get the type of a member var, use the File::getMemberProperties() method, which now contains a "type" array index --- This contains the type of the member var, or a blank string if not specified --- If the type is nullable, the return type will contain the leading ? --- If a type is specified, the position of the first token in the type will be set in a "type_token" array index --- If a type is specified, the position of the last token in the type will be set in a "type_end_token" array index --- If the type is nullable, a "nullable_type" array index will also be set to TRUE --- If the type contains namespace information, it will be cleaned of whitespace and comments in the return value - The PSR1 standard now correctly bans alternate PHP tags -- Previously, it only banned short open tags and not the pre-7.0 alternate tags - Added support for only checking files that have been locally staged in a git repo -- Use --filter=gitstaged to check these files -- You still need to give PHPCS a list of files or directories in which to apply the filter -- Thanks to Juliette Reinders Folmer for the contribution - JSON reports now end with a newline character - The phpcs.xsd schema now validates phpcs-only and phpcbf-only attributes correctly -- Thanks to Juliette Reinders Folmer for the patch - The tokenizer now correctly identifies inline control structures in more cases - All helper methods inside the File class now throw RuntimeException instead of TokenizerException -- Some tokenizer methods were also throwing RuntimeExpection but now correctly throw TokenizerException -- Thanks to Juliette Reinders Folmer for the patch - The File::getMethodParameters() method now returns more information, and supports closure USE groups -- If a type hint is specified, the position of the last token in the hint will be set in a "type_hint_end_token" array index -- If a default is specified, the position of the first token in the default value will be set in a "default_token" array index -- If a default is specified, the position of the equals sign will be set in a "default_equal_token" array index -- If the param is not the last, the position of the comma will be set in a "comma_token" array index -- If the param is passed by reference, the position of the reference operator will be set in a "reference_token" array index -- If the param is variable length, the position of the variadic operator will be set in a "variadic_token" array index - The T_LIST token and it's opening and closing parentheses now contain references to each other in the tokens array -- Uses the same parenthesis_opener/closer/owner indexes as other tokens -- Thanks to Juliette Reinders Folmer for the patch - The T_ANON_CLASS token and it's opening and closing parentheses now contain references to each other in the tokens array -- Uses the same parenthesis_opener/closer/owner indexes as other tokens -- Only applicable if the anon class is passing arguments to the constructor -- Thanks to Juliette Reinders Folmer for the patch - The PHP 7.4 T_BAD_CHARACTER token has been made available for older versions -- Allows you to safely look for this token, but it will not appear unless checking with PHP 7.4+ - Metrics are now available for Squiz.WhiteSpace.FunctionSpacing -- Use the "info" report to see blank lines before/after functions -- Thanks to Juliette Reinders Folmer for the patch - Metrics are now available for Squiz.WhiteSpace.MemberVarSpacing -- Use the "info" report to see blank lines before member vars -- Thanks to Juliette Reinders Folmer for the patch - Added Generic.ControlStructures.DisallowYodaConditions sniff -- Ban the use of Yoda conditions -- Thanks to Mponos George for the contribution - Added Generic.PHP.RequireStrictTypes sniff -- Enforce the use of a strict types declaration in PHP files - Added Generic.WhiteSpace.SpreadOperatorSpacingAfter sniff -- Checks whitespace between the spread operator and the variable/function call it applies to -- Thanks to Juliette Reinders Folmer for the contribution - Added PSR12.Classes.AnonClassDeclaration sniff -- Enforces the formatting of anonymous classes - Added PSR12.Classes.ClosingBrace sniff -- Enforces that closing braces of classes/interfaces/traits/functions are not followed by a comment or statement - Added PSR12.ControlStructures.BooleanOperatorPlacement sniff -- Enforces that boolean operators between conditions are consistently at the start or end of the line - Added PSR12.ControlStructures.ControlStructureSpacing sniff -- Enforces that spacing and indents are correct inside control structure parenthesis - Added PSR12.Files.DeclareStatement sniff -- Enforces the formatting of declare statements within a file - Added PSR12.Files.FileHeader sniff -- Enforces the order and formatting of file header blocks - Added PSR12.Files.ImportStatement sniff -- Enforces the formatting of import statements within a file - Added PSR12.Files.OpenTag sniff -- Enforces that the open tag is on a line by itself when used at the start of a php-only file - Added PSR12.Functions.ReturnTypeDeclaration sniff -- Enforces the formatting of return type declarations in functions and closures - Added PSR12.Properties.ConstantVisibility sniff -- Enforces that constants must have their visibility defined -- Uses a warning instead of an error due to this conditionally requiring the project to support PHP 7.1+ - Added PSR12.Traits.UseDeclaration sniff -- Enforces the formatting of trait import statements within a class - Generic.Files.LineLength ignoreComments property now ignores comments at the end of a line -- Previously, this property was incorrectly causing the sniff to ignore any line that ended with a comment -- Now, the trailing comment is not included in the line length, but the rest of the line is still checked - Generic.Files.LineLength now only ignores unwrappable comments when the comment is on a line by itself -- Previously, a short unwrappable comment at the end of the line would have the sniff ignore the entire line - Generic.Functions.FunctionCallArgumentSpacing no longer checks spacing around assignment operators inside function calls -- Use the Squiz.WhiteSpace.OperatorSpacing sniff to enforce spacing around assignment operators --- Note that this sniff checks spacing around all assignment operators, not just inside function calls -- The Generic.Functions.FunctionCallArgumentSpacing.NoSpaceBeforeEquals error has been removed --- use Squiz.WhiteSpace.OperatorSpacing.NoSpaceBefore instead -- The Generic.Functions.FunctionCallArgumentSpacing.NoSpaceAfterEquals error has been removed --- use Squiz.WhiteSpace.OperatorSpacing.NoSpaceAfter instead -- This also changes the PEAR/PSR2/PSR12 standards so they no longer check assignment operators inside function calls --- They were previously checking these operators when they should not have -- Thanks to Juliette Reinders Folmer for the patch - Generic.WhiteSpace.ScopeIndent no longer performs exact indents checking for chained method calls -- Other sniffs can be used to enforce chained method call indent rules -- Thanks to Pieter Frenssen for the patch - PEAR.WhiteSpace.ObjectOperatorIndent now supports multi-level chained statements -- When enabled, chained calls must be indented 1 level more or less than the previous line -- Set the new "multilevel" setting to TRUE in a ruleset.xml file to enable this behaviour -- Thanks to Marcos Passos for the patch - PSR2.ControlStructures.ControlStructureSpacing now allows whitespace after the opening parenthesis if followed by a comment -- Thanks to Michał Bundyra for the patch - PSR2.Classes.PropertyDeclaration now enforces a single space after a property type keyword -- The PSR2 standard itself excludes this new check as it is not defined in the written standard -- Using the PSR12 standard will enforce this check - Squiz.Commenting.BlockComment no longer requires blank line before comment if it's the first content after the PHP open tag -- Thanks to Juliette Reinders Folmer for the patch - Squiz.Functions.FunctionDeclarationArgumentSpacing now has more accurate error messages -- This includes renaming the SpaceAfterDefault error code to SpaceAfterEquals, which reflects the real error - Squiz.Functions.FunctionDeclarationArgumentSpacing now checks for no space after a reference operator -- If you don't want this new behaviour, exclude the SpacingAfterReference error message in a ruleset.xml file - Squiz.Functions.FunctionDeclarationArgumentSpacing now checks for no space after a variadic operator -- If you don't want this new behaviour, exclude the SpacingAfterVariadic error message in a ruleset.xml file - Squiz.Functions.MultiLineFunctionDeclaration now has improved fixing for the FirstParamSpacing and UseFirstParamSpacing errors - Squiz.Operators.IncrementDecrementUsage now suggests pre-increment of variables instead of post-increment -- This change does not enforce pre-increment over post-increment; only the suggestion has changed -- Thanks to Juliette Reinders Folmer for the patch - Squiz.PHP.DisallowMultipleAssignments now has a second error code for when assignments are found inside control structure conditions -- The new error code is Squiz.PHP.DisallowMultipleAssignments.FoundInControlStructure -- All other multiple assignment cases use the existing error code Squiz.PHP.DisallowMultipleAssignments.Found -- Thanks to Juliette Reinders Folmer for the patch - Squiz.WhiteSpace.FunctionSpacing now applies beforeFirst and afterLast spacing rules to nested functions -- Previously, these rules only applied to the first and last function in a class, interface, or trait -- These rules now apply to functions nested in any statement block, including other functions and conditions - Squiz.WhiteSpace.OperatorSpacing now has improved handling of parse errors -- Thanks to Juliette Reinders Folmer for the patch - Squiz.WhiteSpace.OperatorSpacing now checks spacing around the instanceof operator -- Thanks to Jakub Chábek for the patch - Squiz.WhiteSpace.OperatorSpacing can now enforce a single space before assignment operators -- Previously, the sniff this spacing as multiple assignment operators are sometimes aligned -- Now, you can set the ignoreSpacingBeforeAssignments sniff property to FALSE to enable checking -- Default remains TRUE, so spacing before assignments is not checked by default -- Thanks to Jakub Chábek for the patch - Fixed bug #2391 : Sniff-specific ignore rules inside rulesets are filtering out too many files -- Thanks to Juliette Reinders Folmer and Willington Vega for the patch - Fixed bug #2478 : FunctionCommentThrowTag.WrongNumber when exception is thrown once but built conditionally - Fixed bug #2479 : Generic.WhiteSpace.ScopeIndent error when using array destructing with exact indent checking - Fixed bug #2498 : Squiz.Arrays.ArrayDeclaration.MultiLineNotAllowed autofix breaks heredoc - Fixed bug #2502 : Generic.WhiteSpace.ScopeIndent false positives with nested switch indentation and case fall-through - Fixed bug #2504 : Generic.WhiteSpace.ScopeIndent false positives with nested arrays and nowdoc string - Fixed bug #2511 : PSR2 standard not checking if closing paren of single-line function declaration is on new line - Fixed bug #2512 : Squiz.PHP.NonExecutableCode does not support alternate SWITCH control structure -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2522 : Text generator throws error when code sample line is too long -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2526 : XML report format has bad syntax on Windows -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2529 : Generic.Formatting.MultipleStatementAlignment wrong error for assign in string concat - Fixed bug #2534 : Unresolvable installed_paths can lead to open_basedir errors -- Thanks to Oliver Nowak for the patch - Fixed bug #2541 : Text doc generator does not allow for multi-line rule explanations -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2549 : Searching for a phpcs.xml file can throw warnings due to open_basedir restrictions -- Thanks to Matthew Peveler for the patch - Fixed bug #2558 : PHP 7.4 throwing offset syntax with curly braces is deprecated message -- Thanks to Matthew Peveler for the patch - Fixed bug #2561 : PHP 7.4 compatibility fix / implode argument order -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2562 : Inline WHILE triggers SpaceBeforeSemicolon incorrectly -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2565 : Generic.ControlStructures.InlineControlStructure confused by mixed short/long tags -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2566 : Author tag email validation doesn't support all TLDs -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2575 : Custom error messages don't have data replaced when cache is enabled - Fixed bug #2601 : Squiz.WhiteSpace.FunctionSpacing incorrect fix when spacing is 0 - Fixed bug #2608 : PSR2 throws errors for use statements when multiple namespaces are defined in a file 3.4.2 3.4.2 stable stable 2019-04-11 BSD License - Squiz.Arrays.ArrayDeclaration now has improved handling of syntax errors - Fixed an issue where the PCRE JIT on PHP 7.3 caused PHPCS to die when using the parallel option -- PHPCS now disables the PCRE JIT before running - Fixed bug #2368 : MySource.PHP.AjaxNullComparison throws error when first function has no doc comment - Fixed bug #2414 : Indention false positive in switch/case/if combination - Fixed bug #2423 : Squiz.Formatting.OperatorBracket.MissingBrackets error with static - Fixed bug #2450 : Indentation false positive when closure containing nested IF conditions used as function argument - Fixed bug #2452 : LowercasePHPFunctions sniff failing on "new \File()" - Fixed bug #2453 : Squiz.CSS.SemicolonSpacingSniff false positive when style name proceeded by an asterisk -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2464 : Fixer conflict between Generic.WhiteSpace.ScopeIndent and Squiz.WhiteSpace.ScopeClosingBrace when class indented 1 space - Fixed bug #2465 : Excluding a sniff by path is not working - Fixed bug #2467 : PHP open/close tags inside CSS files are replaced with internal PHPCS token strings when auto fixing 3.4.1 3.4.1 stable stable 2019-03-19 BSD License - The PEAR installable version of PHPCS was missing some files, which have been re-included in this release -- The code report was not previously available for PEAR installs -- The Generic.Formatting.SpaceBeforeCast sniff was not previously available for PEAR installs -- The Generic.WhiteSpace.LanguageConstructSpacing sniff was not previously available for PEAR installs -- Thanks to Juliette Reinders Folmer for the patch - PHPCS will now refuse to run if any of the required PHP extensions are not loaded -- Previously, PHPCS only relied on requirements being checked by PEAR and Composer -- Thanks to Juliette Reinders Folmer for the patch - Ruleset XML parsing errors are now displayed in a readable format so they are easier to correct -- Thanks to Juliette Reinders Folmer for the patch - The PSR2 standard no longer throws duplicate errors for spacing around FOR loop parentheses -- Thanks to Juliette Reinders Folmer for the patch - T_PHPCS_SET tokens now contain sniffCode, sniffProperty, and sniffPropertyValue indexes -- Sniffs can use this information instead of having to parse the token content manually - Added more guard code for syntax errors to various CSS sniffs -- Thanks to Juliette Reinders Folmer for the patch - Generic.Commenting.DocComment error messages now contain the name of the comment tag that caused the error -- Thanks to Juliette Reinders Folmer for the patch - Generic.ControlStructures.InlineControlStructure now handles syntax errors correctly -- Thanks to Juliette Reinders Folmer for the patch - Generic.Debug.JSHint now longer requires rhino and can be run directly from the npm install -- Thanks to Juliette Reinders Folmer for the patch - Generic.Files.LineEndings no longer adds superfluous new line at the end of JS and CSS files -- Thanks to Juliette Reinders Folmer for the patch - Generic.Formatting.DisallowMultipleStatements no longer tries fix lines containing phpcs:ignore statements -- Thanks to Juliette Reinders Folmer for the patch - Generic.Functions.FunctionCallArgumentSpacing now has improved performance and anonymous class support -- Thanks to Juliette Reinders Folmer for the patch - Generic.WhiteSpace.ScopeIndent now respects changes to the "exact" property using phpcs:set mid-way through a file -- This allows you change the "exact" rule for only some parts of a file - Generic.WhiteSpace.ScopeIndent now disables exact indent checking inside all arrays -- Previously, this was only done when using long array syntax, but it now works for short array syntax as well - PEAR.Classes.ClassDeclaration now has improved handling of PHPCS annotations and tab indents - PSR12.Classes.ClassInstantiation has changed it's error code from MissingParenthesis to MissingParentheses - PSR12.Keywords.ShortFormTypeKeywords now ignores all spacing inside type casts during both checking and fixing -- Thanks to Juliette Reinders Folmer for the patch - Squiz.Classes.LowercaseClassKeywords now examines the class keyword for anonymous classes -- Thanks to Juliette Reinders Folmer for the patch - Squiz.ControlStructures.ControlSignature now has improved handling of parse errors -- Thanks to Juliette Reinders Folmer for the patch - Squiz.Commenting.PostStatementComment fixer no longer adds a blank line at the start of a JS file that begins with a comment -- Fixes a conflict between this sniff and the Squiz.WhiteSpace.SuperfluousWhitespace sniff -- Thanks to Juliette Reinders Folmer for the patch - Squiz.Commenting.PostStatementComment now ignores comments inside control structure conditions, such as FOR loops -- Fixes a conflict between this sniff and the Squiz.ControlStructures.ForLoopDeclaration sniff -- Thanks to Juliette Reinders Folmer for the patch - Squiz.Commenting.FunctionCommentThrowTag now has improved support for unknown exception types and namespaces -- Thanks to Juliette Reinders Folmer for the patch - Squiz.ControlStructures.ForLoopDeclaration has improved whitespace, closure, and empty expression support -- The SpacingAfterSecondNoThird error code has been removed as part of these fixes -- Thanks to Juliette Reinders Folmer for the patch - Squiz.CSS.ClassDefinitionOpeningBraceSpace now handles comments and indentation correctly -- Thanks to Juliette Reinders Folmer for the patch - Squiz.CSS.ClassDefinitionClosingBrace now handles comments, indentation, and multiple statements on the same line correctly -- Thanks to Juliette Reinders Folmer for the patch - Squiz.CSS.Opacity now handles comments correctly -- Thanks to Juliette Reinders Folmer for the patch - Squiz.CSS.SemicolonSpacing now handles comments and syntax errors correctly -- Thanks to Juliette Reinders Folmer for the patch - Squiz.NamingConventions.ValidVariableName now supports variables inside anonymous classes correctly -- Thanks to Juliette Reinders Folmer for the patch - Squiz.PHP.LowercasePHPFunctions now handles use statements, namespaces, and comments correctly -- Thanks to Juliette Reinders Folmer for the patch - Squiz.WhiteSpace.FunctionSpacing now fixes function spacing correctly when a function is the first content in a file -- Thanks to Juliette Reinders Folmer for the patch - Squiz.WhiteSpace.SuperfluousWhitespace no longer throws errors for spacing between functions and properties in anon classes -- Thanks to Juliette Reinders Folmer for the patch - Zend.Files.ClosingTag no longer adds a semi-colon during fixing of a file that only contains a comment -- Thanks to Juliette Reinders Folmer for the patch - Zend.NamingConventions.ValidVariableName now supports variables inside anonymous classes correctly -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2298 : PSR2.Classes.ClassDeclaration allows extended class on new line -- Thanks to Michał Bundyra for the patch - Fixed bug #2337 : Generic.WhiteSpace.ScopeIndent incorrect error when multi-line function call starts on same line as open tag - Fixed bug #2348 : Cache not invalidated when changing a ruleset included by another - Fixed bug #2376 : Using __halt_compiler() breaks Generic.PHP.ForbiddenFunctions unless it's last in the function list -- Thanks to Sijun Zhu for the patch - Fixed bug #2393 : The gitmodified filter will infinitely loop when encountering deleted file paths -- Thanks to Lucas Manzke for the patch - Fixed bug #2396 : Generic.WhiteSpace.ScopeIndent incorrect error when multi-line IF condition mixed with HTML - Fixed bug #2431 : Use function/const not tokenized as T_STRING when preceded by comment 3.4.0 3.4.0 stable stable 2018-12-20 BSD License - The Generic.Formatting.NoSpaceAfterCast sniff has been deprecated and will be removed in version 4 -- The functionality of this sniff is now available in the Generic.Formatting.SpaceAfterCast sniff --- Include the Generic.Formatting.SpaceAfterCast sniff and set the "spacing" property to "0" -- As soon as possible, replace all instances of the old sniff code with the new sniff code and property setting --- The existing sniff will continue to work until version 4 has been released - Rule include patterns in a ruleset.xml file are now evaluated as OR instead of AND -- Previously, a file had to match every include pattern and no exclude patterns to be included -- Now, a file must match at least one include pattern and no exclude patterns to be included -- This is a bug fix as include patterns are already documented to work this way - New token T_BITWISE_NOT added for the bitwise not operator -- This token was previously tokenized as T_NONE -- Any sniffs specifically looking for T_NONE tokens with a tilde as the contents must now also look for T_BITWISE_NOT -- Sniffs can continue looking for T_NONE as well as T_BITWISE_NOT to support older PHP_CodeSniffer versions - All types of binary casting are now tokenized as T_BINARY_CAST -- Previously, the 'b' in 'b"some string with $var"' would be a T_BINARY_CAST, but only when the string contained a var -- This change ensures the 'b' is always tokenized as T_BINARY_CAST -- This change also converts '(binary)' from T_STRING_CAST to T_BINARY_CAST -- Thanks to Juliette Reinders Folmer for the help with this patch - Array properties set inside a ruleset.xml file can now extend a previous value instead of always overwriting it -- e.g., if you include a ruleset that defines forbidden functions, can you now add to that list instead of having to redefine it -- To use this feature, add extends="true" to the property tag --- e.g., property name="forbiddenFunctionNames" type="array" extend="true" -- Thanks to Michael Moravec for the patch - If $XDG_CACHE_HOME is set and points to a valid directory, it will be used for caching instead of the system temp directory - PHPCBF now disables parallel running if you are passing content on STDIN -- Stops an error from being shown after the fixed output is printed - The progress report now shows files with tokenizer errors as skipped (S) instead of a warning (W) -- The tokenizer error is still displayed in reports as normal -- Thanks to Juliette Reinders Folmer for the patch - The Squiz standard now ensures there is no space between an increment/decrement operator and its variable - The File::getMethodProperties() method now includes a has_body array index in the return value -- FALSE if the method has no body (as with abstract and interface methods) or TRUE otherwise -- Thanks to Chris Wilkinson for the patch - The File::getTokensAsString() method now throws an exception if the $start param is invalid -- If the $length param is invalid, an empty string will be returned -- Stops an infinite loop when the function is passed invalid data -- Thanks to Juliette Reinders Folmer for the patch - Added new Generic.CodeAnalysis.EmptyPHPStatement sniff -- Warns when it finds empty PHP open/close tag combinations or superfluous semicolons -- Thanks to Juliette Reinders Folmer for the contribution - Added new Generic.Formatting.SpaceBeforeCast sniff -- Ensures there is exactly 1 space before a type cast, unless the cast statement is indented or multi-line -- Thanks to Juliette Reinders Folmer for the contribution - Added new Generic.VersionControl.GitMergeConflict sniff -- Detects merge conflict artifacts left in files -- Thanks to Juliette Reinders Folmer for the contribution - Added Generic.WhiteSpace.IncrementDecrementSpacing sniff -- Ensures there is no space between the operator and the variable it applies to -- Thanks to Juliette Reinders Folmer for the contribution - Added PSR12.Functions.NullableTypeDeclaration sniff -- Ensures there is no space after the question mark in a nullable type declaration -- Thanks to Timo Schinkel for the contribution - A number of sniffs have improved support for methods in anonymous classes -- These sniffs would often throw the same error twice for functions in nested classes -- Error messages have also been changed to be less confusing -- The full list of affected sniffs is: --- Generic.NamingConventions.CamelCapsFunctionName --- PEAR.NamingConventions.ValidFunctionName --- PSR1.Methods.CamelCapsMethodName --- PSR2.Methods.MethodDeclaration --- Squiz.Scope.MethodScope --- Squiz.Scope.StaticThisUsage -- Thanks to Juliette Reinders Folmer for the patch - Generic.CodeAnalysis.UnusedFunctionParameter now only skips functions with empty bodies when the class implements an interface -- Thanks to Juliette Reinders Folmer for the patch - Generic.CodeAnalysis.UnusedFunctionParameter now has additional error codes to indicate where unused params were found -- The new error code prefixes are: --- FoundInExtendedClass: when the class extends another --- FoundInImplementedInterface: when the class implements an interface --- Found: used in all other cases, including closures -- The new error code suffixes are: --- BeforeLastUsed: the unused param was positioned before the last used param in the function signature --- AfterLastUsed: the unused param was positioned after the last used param in the function signature -- This makes the new error code list for this sniff: --- Found --- FoundBeforeLastUsed --- FoundAfterLastUsed --- FoundInExtendedClass --- FoundInExtendedClassBeforeLastUsed --- FoundInExtendedClassAfterLastUsed --- FoundInImplementedInterface --- FoundInImplementedInterfaceBeforeLastUsed --- FoundInImplementedInterfaceAfterLastUsed -- These errors code make it easier for specific cases to be ignored or promoted using a ruleset.xml file -- Thanks to Juliette Reinders Folmer for the contribution - Generic.Classes.DuplicateClassName now inspects traits for duplicate names as well as classes and interfaces -- Thanks to Chris Wilkinson for the patch - Generic.Files.InlineHTML now ignores a BOM at the start of the file -- Thanks to Chris Wilkinson for the patch - Generic.PHP.CharacterBeforePHPOpeningTag now ignores a BOM at the start of the file -- Thanks to Chris Wilkinson for the patch - Generic.Formatting.SpaceAfterCast now has a setting to specify how many spaces are required after a type cast -- Default remains 1 -- Override the "spacing" setting in a ruleset.xml file to change -- Thanks to Juliette Reinders Folmer for the patch - Generic.Formatting.SpaceAfterCast now has a setting to ignore newline characters after a type cast -- Default remains FALSE, so newlines are not allowed -- Override the "ignoreNewlines" setting in a ruleset.xml file to change -- Thanks to Juliette Reinders Folmer for the patch - Generic.Formatting.SpaceAfterNot now has a setting to specify how many spaces are required after a NOT operator -- Default remains 1 -- Override the "spacing" setting in a ruleset.xml file to change -- Thanks to Juliette Reinders Folmer for the patch - Generic.Formatting.SpaceAfterNot now has a setting to ignore newline characters after the NOT operator -- Default remains FALSE, so newlines are not allowed -- Override the "ignoreNewlines" setting in a ruleset.xml file to change -- Thanks to Juliette Reinders Folmer for the patch - PEAR.Functions.FunctionDeclaration now checks spacing before the opening parenthesis of functions with no body -- Thanks to Chris Wilkinson for the patch - PEAR.Functions.FunctionDeclaration now enforces no space before the semicolon in functions with no body -- Thanks to Chris Wilkinson for the patch - PSR2.Classes.PropertyDeclaration now checks the order of property modifier keywords -- This is a rule that is documented in PSR-2 but was not enforced by the included PSR2 standard until now -- This sniff is also able to fix the order of the modifier keywords if they are incorrect -- Thanks to Juliette Reinders Folmer for the patch - PSR2.Methods.MethodDeclaration now checks method declarations inside traits -- Thanks to Chris Wilkinson for the patch - Squiz.Commenting.InlineComment now has better detection of comment block boundaries - Squiz.Classes.ClassFileName now checks that a trait name matches the filename -- Thanks to Chris Wilkinson for the patch - Squiz.Classes.SelfMemberReference now supports scoped declarations and anonymous classes -- Thanks to Juliette Reinders Folmer for the patch - Squiz.Classes.SelfMemberReference now fixes multiple errors at once, increasing fixer performance -- Thanks to Gabriel Ostrolucký for the patch - Squiz.Functions.LowercaseFunctionKeywords now checks abstract and final prefixes, and auto-fixes errors -- Thanks to Juliette Reinders Folmer for the patch - Squiz.Objects.ObjectMemberComma.Missing has been renamed to Squiz.Objects.ObjectMemberComma.Found -- The error is thrown when the comma is found but not required, so the error code was incorrect -- If you are referencing the old error code in a ruleset XML file, please use the new code instead -- If you wish to maintain backwards compatibility, you can provide rules for both the old and new codes -- Thanks to Juliette Reinders Folmer for the patch - Squiz.WhiteSpace.ObjectOperatorSpacing is now more tolerant of parse errors - Squiz.WhiteSpace.ObjectOperatorSpacing now fixes errors more efficiently -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2109 : Generic.Functions.CallTimePassByReference false positive for bitwise and used in function argument - Fixed bug #2165 : Conflict between Squiz.Arrays.ArrayDeclaration and ScopeIndent sniffs when heredoc used in array - Fixed bug #2167 : Generic.WhiteSpace.ScopeIndent shows invalid error when scope opener indented inside inline HTML - Fixed bug #2178 : Generic.NamingConventions.ConstructorName matches methods in anon classes with same name as containing class -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2190 : PEAR.Functions.FunctionCallSignature incorrect error when encountering trailing PHPCS annotation -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2194 : Generic.Whitespace.LanguageConstructSpacing should not be checking namespace operators -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2202 : Squiz.WhiteSpace.OperatorSpacing throws error for negative index when using curly braces for string access -- Same issue fixed in Squiz.Formatting.OperatorBracket -- Thanks to Andreas Buchenrieder for the patch - Fixed bug #2210 : Generic.NamingConventions.CamelCapsFunctionName not ignoring SoapClient __getCookies() method -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2211 : PSR2.Methods.MethodDeclaration gets confused over comments between modifier keywords -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2212 : FUNCTION and CONST in use groups being tokenised as T_FUNCTION and T_CONST -- Thanks to Chris Wilkinson for the patch - Fixed bug #2214 : File::getMemberProperties() is recognizing method params as properties -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2236 : Memory info measurement unit is Mb but probably should be MB - Fixed bug #2246 : CSS tokenizer does not tokenize class names correctly when they contain the string NEW -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2278 : Squiz.Operators.ComparisonOperatorUsage false positive when inline IF contained in parentheses -- Thanks to Arnout Boks for the patch - Fixed bug #2284 : Squiz.Functions.FunctionDeclarationArgumentSpacing removing type hint during fixing -- Thanks to Michał Bundyra for the patch - Fixed bug #2297 : Anonymous class not tokenized correctly when used as argument to another anon class -- Thanks to Michał Bundyra for the patch 2.9.2 2.9.2 stable stable 2018-11-08 BSD License - PHPCS should now run under PHP 7.3 without deprecation warnings -- Thanks to Nick Wilde for the patch - Fixed bug #1496 : Squiz.Strings.DoubleQuoteUsage not unescaping dollar sign when fixing -- Thanks to Michał Bundyra for the patch - Fixed bug #1549 : Squiz.PHP.EmbeddedPhp fixer conflict with // comment before PHP close tag -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #1890 : Incorrect Squiz.WhiteSpace.ControlStructureSpacing.NoLineAfterClose error between catch and finally statements 3.3.2 3.3.2 stable stable 2018-09-24 BSD License - Fixed a problem where the report cache was not being cleared when the sniffs inside a standard were updated - The info report (--report=info) now has improved formatting for metrics that span multiple lines -- Thanks to Juliette Reinders Folmer for the patch - The unit test runner now skips .bak files when looking for test cases -- Thanks to Juliette Reinders Folmer for the patch - The Squiz standard now ensures underscores are not used to indicate visibility of private members vars and methods -- Previously, this standard enforced the use of underscores - Generic.PHP.NoSilencedErrors error messages now contain a code snippet to show the context of the error -- Thanks to Juliette Reinders Folmer for the patch - Squiz.Arrays.ArrayDeclaration no longer reports errors for a comma on a line new after a here/nowdoc -- Also stops a parse error being generated when auto-fixing -- The SpaceBeforeComma error message has been changed to only have one data value instead of two - Squiz.Commenting.FunctionComment no longer errors when trying to fix indents of multi-line param comments - Squiz.Formatting.OperatorBracket now correctly fixes statements that contain strings - Squiz.PHP.CommentedOutCode now ignores more @-style annotations and includes better comment block detection -- Thanks to Juliette Reinders Folmer for the patch - Fixed a problem where referencing a relative file path in a ruleset XML file could add unnecessary sniff exclusions -- This didn't actually exclude anything, but caused verbose output to list strange exclusion rules - Fixed bug #2110 : Squiz.WhiteSpace.FunctionSpacing is removing indents from the start of functions when fixing -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2115 : Squiz.Commenting.VariableComment not checking var types when the @var line contains a comment - Fixed bug #2120 : Tokenizer fails to match T_INLINE_ELSE when used after function call containing closure - Fixed bug #2121 : Squiz.PHP.DisallowMultipleAssignments false positive in while loop conditions -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2127 : File::findExtendedClassName() doesn't support nested classes -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2138 : Tokenizer detects wrong token for php ::class feature with spaces - Fixed bug #2143 : PSR2.Namespaces.UseDeclaration does not properly fix "use function" and "use const" statements -- Thanks to Chris Wilkinson for the patch - Fixed bug #2144 : Squiz.Arrays.ArrayDeclaration does incorrect align calculation in array with cyrillic keys - Fixed bug #2146 : Zend.Files.ClosingTag removes closing tag from end of file without inserting a semicolon - Fixed bug #2151 : XML schema not updated with the new array property syntax 3.3.1 3.3.1 stable stable 2018-07-27 BSD License - Support for HHVM has been dropped due to recent unfixed bugs and HHVM refocus on Hack only -- Thanks to Walt Sorensen and Juliette Reinders Folmer for helping to remove all HHVM exceptions from the core - The full report (the default report) now has improved word wrapping for multi-line messages and sniff codes -- Thanks to Juliette Reinders Folmer for the patch - The summary report now sorts files based on their directory location instead of just a basic string sort -- Thanks to Juliette Reinders Folmer for the patch - The source report now orders error codes by name when they have the same number of errors -- Thanks to Juliette Reinders Folmer for the patch - The junit report no longer generates validation errors with the Jenkins xUnit plugin -- Thanks to Nikolay Geo for the patch - Generic.Commenting.DocComment no longer generates the SpacingBeforeTags error if tags are the first content in the docblock -- The sniff will still generate a MissingShort error if there is no short comment -- This allows the MissingShort error to be suppressed in a ruleset to make short descriptions optional - Generic.Functions.FunctionCallArgumentSpacing now properly fixes multi-line function calls with leading commas -- Previously, newlines between function arguments would be removed -- Thanks to Juliette Reinders Folmer for the patch - Generic.PHP.Syntax will now use PHP_BINARY instead of trying to discover the executable path -- This ensures that the sniff will always syntax check files using the PHP version that PHPCS is running under -- Setting the php_path config var will still override this value as normal -- Thanks to Willem Stuursma-Ruwen for the patch - PSR2.Namespaces.UseDeclaration now supports commas at the end of group use declarations -- Also improves checking and fixing for use statements containing parse errors -- Thanks to Juliette Reinders Folmer for the patch - Squiz.Arrays.ArrayDeclaration no longer removes the array opening brace while fixing -- This could occur when the opening brace was on a new line and the first array key directly followed -- This change also stops the KeyNotAligned error message being incorrectly reported in these cases - Squiz.Arrays.ArrayDeclaration no longer tries to change multi-line arrays to single line when they contain comments -- Fixes a conflict between this sniff and some indentation sniffs - Squiz.Classes.ClassDeclaration no longer enforces spacing rules when a class is followed by a function -- Fixes a conflict between this sniff and the Squiz.WhiteSpace.FunctionSpacing sniff - The Squiz.Classes.ValidClassName.NotCamelCaps message now references PascalCase instead of CamelCase -- The "CamelCase class name" metric produced by the sniff has been changed to "PascalCase class name" -- This reflects the fact that the class name check is actually a Pascal Case check and not really Camel Case -- Thanks to Tom H Anderson for the patch - Squiz.Commenting.InlineComment no longer enforces spacing rules when an inline comment is followed by a docblock -- Fixes a conflict between this sniff and the Squiz.WhiteSpace.FunctionSpacing sniff - Squiz.WhiteSpace.OperatorSpacing no longer tries to fix operator spacing if the next content is a comment on a new line -- Fixes a conflict between this sniff and the Squiz.Commenting.PostStatementComment sniff -- Also stops PHPCS annotations from being moved to a different line, potentially changing their meaning -- Thanks to Juliette Reinders Folmer for the patch - Squiz.WhiteSpace.FunctionSpacing no longer checks spacing of functions at the top of an embedded PHP block -- Fixes a conflict between this sniff and the Squiz.PHP.EmbeddedPHP sniff -- Thanks to Juliette Reinders Folmer for the patch - Squiz.WhiteSpace.MemberVarSpacing no longer checks spacing before member vars that come directly after methods -- Fixes a conflict between this sniff and the Squiz.WhiteSpace.FunctionSpacing sniff - Squiz.WhiteSpace.SuperfluousWhitespace now recognizes unicode whitespace at the start and end of a file -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2029 : Squiz.Scope.MemberVarScope throws fatal error when a property is found in an interface -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2047 : PSR12.Classes.ClassInstantiation false positive when instantiating class from array index - Fixed bug #2048 : GenericFormatting.MultipleStatementAlignment false positive when assigning values inside an array - Fixed bug #2053 : PSR12.Classes.ClassInstantiation incorrectly fix when using member vars and some variable formats - Fixed bug #2065 : Generic.ControlStructures.InlineControlStructure fixing fails when inline control structure contains closure - Fixed bug #2072 : Squiz.Arrays.ArrayDeclaration throws NoComma error when array value is a shorthand IF statement - Fixed bug #2082 : File with "defined() or define()" syntax triggers PSR1.Files.SideEffects.FoundWithSymbols - Fixed bug #2095 : PSR2.Namespaces.NamespaceDeclaration does not handle namespaces defined over multiple lines 3.3.0 3.3.0 stable stable 2018-06-07 BSD License - The Squiz.WhiteSpace.LanguageConstructSpacing sniff has been deprecated and will be removed in version 4 -- The sniff has been moved to the Generic standard, with a new code of Generic.WhiteSpace.LanguageConstructSpacing -- As soon as possible, replace all instances of the old sniff code with the new sniff code in your ruleset.xml files --- The existing Squiz sniff will continue to work until version 4 has been released -- The new Generic sniff now also checks many more language constructs to enforce additional spacing rules --- Thanks to Mponos George for the contribution - The current method for setting array properties in ruleset files has been deprecated and will be removed in version 4 -- Currently, setting an array value uses the string syntax "print=>echo,create_function=>null" -- Now, individual array elements are specified using a new "element" tag with "key" and "value" attributes --- For example, element key="print" value="echo" -- Thanks to Michał Bundyra for the patch - The T_ARRAY_HINT token has been deprecated and will be removed in version 4 -- The token was used to ensure array type hints were not tokenized as T_ARRAY, but no other type hints were given a special token -- Array type hints now use the standard T_STRING token instead -- Sniffs referencing this token type will continue to run without error until version 4, but will not find any T_ARRAY_HINT tokens - The T_RETURN_TYPE token has been deprecated and will be removed in version 4 -- The token was used to ensure array/self/parent/callable return types were tokenized consistently -- For namespaced return types, only the last part of the string (the class name) was tokenized as T_RETURN_TYPE -- This was not consistent and so return types are now left using their original token types so they are not skipped by sniffs --- The exception are array return types, which are tokenized as T_STRING instead of T_ARRAY, as they are for type hints -- Sniffs referencing this token type will continue to run without error until version 4, but will not find any T_RETUTN_TYPE tokens -- To get the return type of a function, use the File::getMethodProperties() method, which now contains a "return_type" array index --- This contains the return type of the function or closer, or a blank string if not specified --- If the return type is nullable, the return type will contain the leading ? ---- A nullable_return_type array index in the return value will also be set to true --- If the return type contains namespace information, it will be cleaned of whitespace and comments ---- To access the original return value string, use the main tokens array - This release contains an incomplete version of the PSR-12 coding standard -- Errors found using this standard should be valid, but it will miss a lot of violations until it is complete -- If you'd like to test and help, you can use the standard by running PHPCS with --standard=PSR12 - Config values set using --runtime-set now override any config values set in rulesets or the CodeSniffer.conf file - You can now apply include-pattern rules to individual message codes in a ruleset like you can with exclude-pattern rules -- Previously, include-pattern rules only applied to entire sniffs -- If a message code has both include and exclude patterns, the exclude patterns will be ignored - Using PHPCS annotations to selectively re-enable sniffs is now more flexible -- Previously, you could only re-enable a sniff/category/standard using the exact same code that was disabled -- Now, you can disable a standard and only re-enable a specific category or sniff -- Or, you can disable a specific sniff and have it re-enable when you re-enable the category or standard - The value of array sniff properties can now be set using phpcs:set annotations -- e.g., phpcs:set Standard.Category.SniffName property[] key=>value,key2=>value2 -- Thanks to Michał Bundyra for the patch - PHPCS annotations now remain as T_PHPCS_* tokens instead of reverting to comment tokens when --ignore-annotations is used -- This stops sniffs (especially commenting sniffs) from generating a large number of false errors when ignoring -- Any custom sniffs that are using the T_PHPCS_* tokens to detect annotations may need to be changed to ignore them --- Check $phpcsFile->config->annotations to see if annotations are enabled and ignore when false - You can now use fully or partially qualified class names for custom reports instead of absolute file paths -- To support this, you must specify an autoload file in your ruleset.xml file and use it to register an autoloader -- Your autoloader will need to load your custom report class when requested -- Thanks to Juliette Reinders Folmer for the patch - The JSON report format now does escaping in error source codes as well as error messages -- Thanks to Martin Vasel for the patch - Invalid installed_paths values are now ignored instead of causing a fatal error - Improved testability of custom rulesets by allowing the installed standards to be overridden -- Thanks to Timo Schinkel for the patch - The key used for caching PHPCS runs now includes all set config values -- This fixes a problem where changing config values (e.g., via --runtime-set) used an incorrect cache file - The "Function opening brace placement" metric has been separated into function and closure metrics in the info report -- Closures are no longer included in the "Function opening brace placement" metric -- A new "Closure opening brace placement" metric now shows information for closures - Multi-line T_YIELD_FROM statements are now replicated properly for older PHP versions - The PSR2 standard no longer produces 2 error messages when the AS keyword in a foreach loop is not lowercase - Specifying a path to a non-existent dir when using the --report-[reportType]=/path/to/report CLI option no longer throws an exception -- This now prints a readable error message, as it does when using --report-file - The File::getMethodParamaters() method now includes a type_hint_token array index in the return value -- Provides the position in the token stack of the first token in the type hint - The File::getMethodProperties() method now includes a return_type_token array index in the return value -- Provides the position in the token stack of the first token in the return type - The File::getTokensAsString() method can now optionally return original (non tab-replaced) content -- Thanks to Juliette Reinders Folmer for the patch - Removed Squiz.PHP.DisallowObEndFlush from the Squiz standard -- If you use this sniff and want to continue banning ob_end_flush(), use Generic.PHP.ForbiddenFunctions instead -- You will need to set the forbiddenFunctions property in your ruleset.xml file - Removed Squiz.PHP.ForbiddenFunctions from the Squiz standard -- Replaced by using the forbiddenFunctions property of Generic.PHP.ForbiddenFunctions in the Squiz ruleset.xml -- Functionality of the Squiz standard remains the same, but the error codes are now different -- Previously, Squiz.PHP.ForbiddenFunctions.Found and Squiz.PHP.ForbiddenFunctions.FoundWithAlternative -- Now, Generic.PHP.ForbiddenFunctions.Found and Generic.PHP.ForbiddenFunctions.FoundWithAlternative - Added new Generic.PHP.LowerCaseType sniff -- Ensures PHP types used for type hints, return types, and type casting are lowercase -- Thanks to Juliette Reinders Folmer for the contribution - Added new Generic.WhiteSpace.ArbitraryParenthesesSpacing sniff -- Generates an error for whitespace inside parenthesis that don't belong to a function call/declaration or control structure -- Generates a warning for any empty parenthesis found -- Allows the required spacing to be set using the spacing sniff property (default is 0) -- Allows newlines to be used by setting the ignoreNewlines sniff property (default is false) -- Thanks to Juliette Reinders Folmer for the contribution - Added new PSR12.Classes.ClassInstantiation sniff -- Ensures parenthesis are used when instantiating a new class - Added new PSR12.Keywords.ShortFormTypeKeywords sniff -- Ensures the short form of PHP types is used when type casting - Added new PSR12.Namespaces.CompundNamespaceDepth sniff -- Ensures compound namespace use statements have a max depth of 2 levels -- The max depth can be changed by setting the 'maxDepth' sniff property in a ruleset.xml file - Added new PSR12.Operators.OperatorSpacing sniff -- Ensures operators are preceded and followed by at least 1 space - Improved core support for grouped property declarations -- Also improves support in Squiz.WhiteSpace.ScopeKeywordSpacing and Squiz.WhiteSpace.MemberVarSpacing -- Thanks to Juliette Reinders Folmer for the patch - Generic.Commenting.DocComment now produces a NonParamGroup error when tags are mixed in with the @param tag group -- It would previously throw either a NonParamGroup or ParamGroup error depending on the order of tags -- This change allows the NonParamGroup error to be suppressed in a ruleset to allow the @param group to contain other tags -- Thanks to Phil Davis for the patch - Generic.Commenting.DocComment now continues checks param tags even if the doc comment short description is missing -- This change allows the MissingShort error to be suppressed in a ruleset without all other errors being suppressed as well -- Thanks to Phil Davis for the patch - Generic.CodeAnalysis.AssignmentInCondition now reports a different error code for assignments found in WHILE conditions -- The return value of a function call is often assigned in a WHILE condition, so this change makes it easier to exclude these cases -- The new code for this error message is Generic.CodeAnalysis.AssignmentInCondition.FoundInWhileCondition -- The error code for all other cases remains as Generic.CodeAnalysis.AssignmentInCondition.Found -- Thanks to Juliette Reinders Folmer for the patch - Generic.Functions.OpeningFunctionBraceBsdAllman now longer leaves trailing whitespace when moving the opening brace during fixing -- Also applies to fixes made by PEAR.Functions.FunctionDeclaration and Squiz.Functions.MultiLineFunctionDeclaration - Generic.WhiteSpace.ScopeIndent now does a better job of fixing the indent of multi-line comments - Generic.WhiteSpace.ScopeIndent now does a better job of fixing the indent of PHP open and close tags - PEAR.Commenting.FunctionComment now report a different error code for param comment lines with too much padding -- Previously, any lines of a param comment that don't start at the exact comment position got the same error code -- Now, only comment lines with too little padding use ParamCommentAlignment as they are clearly mistakes -- Comment lines with too much padding may be using precision alignment as now use ParamCommentAlignmentExceeded -- This allows for excessive padding to be excluded from a ruleset while continuing to enforce a minimum padding - PEAR.WhiteSpace.ObjectOperatorIndent now checks the indent of more chained operators -- Previously, it only checked chains beginning with a variable -- Now, it checks chains beginning with function calls, static class names, etc - Squiz.Arrays.ArrayDeclaration now continues checking array formatting even if the key indent is not correct -- Allows for using different array indent rules while still checking/fixing double arrow and value alignment - Squiz.Commenting.BlockComment has improved support for tab-indented comments -- Thanks to Juliette Reinders Folmer for the patch - Squiz.Commenting.BlockComment auto fixing no longer breaks when two block comments follow each other -- Also stopped single-line block comments from being auto fixed when they are embedded in other code -- Also fixed as issue found when PHPCS annotations were used inside a block comment -- Thanks to Juliette Reinders Folmer for the patch - Squiz.Commenting.BlockComment.LastLineIndent is now able to be fixed with phpcbf -- Thanks to Juliette Reinders Folmer for the patch - Squiz.Commenting.BlockComment now aligns star-prefixed lines under the opening tag while fixing, instead of indenting them -- Thanks to Juliette Reinders Folmer for the patch - Squiz.Commenting.FunctionComment.IncorrectTypeHint message no longer contains cut-off suggested type hints - Squiz.Commenting.InlineComment now uses a new error code for inline comments at the end of a function -- Previously, all inline comments followed by a blank line threw a Squiz.Commenting.InlineComment.SpacingAfter error -- Now, inline comments at the end of a function will instead throw Squiz.Commenting.InlineComment.SpacingAfterAtFunctionEnd -- If you previously excluded SpacingAfter, add an exclusion for SpacingAfterAtFunctionEnd to your ruleset as well -- If you previously only included SpacingAfter, consider including SpacingAfterAtFunctionEnd as well -- The Squiz standard now excludes SpacingAfterAtFunctionEnd as the blank line is checked elsewhere -- Thanks to Juliette Reinders Folmer for the patch - Squiz.ControlStructures.ControlSignature now errors when a comment follows the closing brace of an earlier body -- Applies to catch, finally, else, elseif, and do/while structures -- The included PSR2 standard now enforces this rule -- Thanks to Juliette Reinders Folmer for the patch - Squiz.Formatting.OperatorBracket.MissingBrackets message has been changed to remove the word "arithmetic" -- The sniff checks more than just arithmetic operators, so the message is now clearer - Sniffs.Operators.ComparisonOperatorUsage now detects more cases of implicit true comparisons -- It could previously be confused by comparisons used as function arguments - Squiz.PHP.CommentedOutCode now ignores simple @-style annotation comments so they are not flagged as commented out code -- Thanks to Juliette Reinders Folmer for the patch - Squiz.PHP.CommentedOutCode now ignores a greater number of short comments so they are not flagged as commented out code -- Thanks to Juliette Reinders Folmer for the patch - Squiz.PHP.DisallowComparisonAssignment no longer errors when using the null coalescing operator -- Given this operator is used almost exclusively to assign values, it didn't make sense to generate an error - Squiz.WhiteSpacing.FunctionSpacing now has a property to specify how many blank lines should be before the first class method -- Only applies when a method is the first code block in a class (i.e., there are no member vars before it) -- Override the 'spacingBeforeFirst' property in a ruleset.xml file to change -- If not set, the sniff will use whatever value is set for the existing 'spacing' property - Squiz.WhiteSpacing.FunctionSpacing now has a property to specify how many blank lines should be after the last class method -- Only applies when a method is the last code block in a class (i.e., there are no member vars after it) -- Override the 'spacingAfterLast' property in a ruleset.xml file to change -- If not set, the sniff will use whatever value is set for the existing 'spacing' property - Fixed bug #1863 : File::findEndOfStatement() not working when passed a scope opener - Fixed bug #1876 : PSR2.Namespaces.UseDeclaration not giving error for use statements before the namespace declaration -- Adds a new PSR2.Namespaces.UseDeclaration.UseBeforeNamespace error message - Fixed bug #1881 : Generic.Arrays.ArrayIndent is indenting sub-arrays incorrectly when comma not used after the last value - Fixed bug #1882 : Conditional with missing braces confused by indirect variables - Fixed bug #1915 : JS tokenizer fails to tokenize regular expression proceeded by boolean not operator - Fixed bug #1920 : Directory exclude pattern improperly excludes files with names that start the same -- Thanks to Jeff Puckett for the patch - Fixed bug #1922 : Equal sign alignment check broken when list syntax used before assignment operator - Fixed bug #1925 : Generic.Formatting.MultipleStatementAlignment skipping assignments within closures - Fixed bug #1931 : Generic opening brace placement sniffs do not correctly support function return types - Fixed bug #1932 : Generic.ControlStructures.InlineControlStructure fixer moves new PHPCS annotations - Fixed bug #1938 : Generic opening brace placement sniffs incorrectly move PHPCS annotations -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #1939 : phpcs:set annotations do not cause the line they are on to be ignored -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #1949 : Squiz.PHP.DisallowMultipleAssignments false positive when using namespaces with static assignments - Fixed bug #1959 : SquizMultiLineFunctionDeclaration error when param has trailing comment -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #1963 : Squiz.Scope.MemberVarScope does not work for multiline member declaration -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #1971 : Short array list syntax not correctly tokenized if short array is the first content in a file - Fixed bug #1979 : Tokenizer does not change heredoc to nowdoc token if the start tag contains spaces - Fixed bug #1982 : Squiz.Arrays.ArrayDeclaration fixer sometimes puts a comma in front of the last array value - Fixed bug #1993 : PSR1/PSR2 not reporting or fixing short open tags - Fixed bug #1996 : Custom report paths don't work on case-sensitive filesystems - Fixed bug #2006 : Squiz.Functions.FunctionDeclarationArgumentSpacing fixer removes comment between parens when no args -- The SpacingAfterOpenHint error message has been removed --- It is replaced by the the existing SpacingAfterOpen message -- The error message format for the SpacingAfterOpen and SpacingBeforeClose messages has been changed --- These used to contain 3 pieces of data, but now only contain 2 -- If you have customised the error messages of this sniff, please review your ruleset after upgrading - Fixed bug #2018 : Generic.Formatting.MultipleStatementAlignment does see PHP close tag as end of statement block -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #2027 : PEAR.NamingConventions.ValidFunctionName error when function name includes double underscore -- Thanks to Juliette Reinders Folmer for the patch 3.2.3 3.2.3 stable stable 2018-02-21 BSD License - The new phpcs: comment syntax can now be prefixed with an at symbol ( @phpcs: ) -- This restores the behaviour of the previous syntax where these comments are ignored by doc generators - The current PHP version ID is now used to generate cache files -- This ensures that only cache files generated by the current PHP version are selected -- This change fixes caching issues when using sniffs that produce errors based on the current PHP version - A new Tokens::$phpcsCommentTokens array is now available for sniff developers to detect phpcs: comment syntax -- Thanks to Juliette Reinders Folmer for the patch - The PEAR.Commenting.FunctionComment.Missing error message now includes the name of the function -- Thanks to Yorman Arias for the patch - The PEAR.Commenting.ClassComment.Missing and Squiz.Commenting.ClassComment.Missing error messages now include the name of the class -- Thanks to Yorman Arias for the patch - PEAR.Functions.FunctionCallSignature now only forces alignment at a specific tab stop while fixing -- It was enforcing this during checking, but this meant invalid errors if the OpeningIndent message was being muted -- This fixes incorrect errors when using the PSR2 standard with some code blocks - Generic.Files.LineLength now ignores lines that only contain phpcs: annotation comments -- Thanks to Juliette Reinders Folmer for the patch - Generic.Formatting.MultipleStatementAlignment now skips over arrays containing comments -- Thanks to Juliette Reinders Folmer for the patch - Generic.PHP.Syntax now forces display_errors to ON when linting -- Thanks to Raúl Arellano for the patch - PSR2.Namespaces.UseDeclaration has improved syntax error handling and closure detection -- Thanks to Juliette Reinders Folmer for the patch - Squiz.PHP.CommentedOutCode now has improved comment block detection for improved accuracy -- Thanks to Juliette Reinders Folmer for the patch - Squiz.PHP.NonExecutableCode could fatal error while fixing file with syntax error - Squiz.PHP.NonExecutableCode now detects unreachable code after a goto statement -- Thanks to Juliette Reinders Folmer for the patch - Squiz.WhiteSpace.LanguageConstructSpacing has improved syntax error handling while fixing -- Thanks to Juliette Reinders Folmer for the patch - Improved phpcs: annotation syntax handling for a number of sniffs -- Thanks to Juliette Reinders Folmer for the patch - Improved auto-fixing of files with incomplete comment blocks for various commenting sniffs -- Thanks to Juliette Reinders Folmer for the patch - Fixed test suite compatibility with PHPUnit 7 - Fixed bug #1793 : PSR2 forcing exact indent for function call opening statements - Fixed bug #1803 : Squiz.WhiteSpace.ScopeKeywordSpacing removes member var name while fixing if no space after scope keyword - Fixed bug #1817 : Blank line not enforced after control structure if comment on same line as closing brace - Fixed bug #1827 : A phpcs:enable comment is not tokenized correctly if it is outside a phpcs:disable block -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #1828 : Squiz.WhiteSpace.SuperfluousWhiteSpace ignoreBlankLines property ignores whitespace after single line comments -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #1840 : When a comment has too many asterisks, phpcbf gives FAILED TO FIX error - Fixed bug #1867 : Cant use phpcs:ignore where the next line is HTML - Fixed bug #1870 : Invalid warning in multiple assignments alignment with closure or anon class - Fixed bug #1890 : Incorrect Squiz.WhiteSpace.ControlStructureSpacing.NoLineAfterClose error between catch and finally statements - Fixed bug #1891 : Comment on last USE statement causes false positive for PSR2.Namespaces.UseDeclaration.SpaceAfterLastUse -- Thanks to Matt Coleman, Daniel Hensby, and Juliette Reinders Folmer for the patch - Fixed bug #1901 : Fixed PHPCS annotations in multi-line tab-indented comments + not ignoring whole line for phpcs:set -- Thanks to Juliette Reinders Folmer for the patch 3.2.2 3.2.2 stable stable 2017-12-20 BSD License - Disabled STDIN detection on Windows -- This fixes a problem with IDE plugins (e.g., PHPStorm) hanging on Windows 3.2.1 3.2.1 stable stable 2017-12-18 BSD License - Fixed problems with some scripts and plugins waiting for STDIN -- This was a notable problem with IDE plugins (e.g., PHPStorm) and build systems - Empty diffs are no longer followed by a newline character (request #1781) - Generic.Functions.OpeningFunctionBraceKernighanRitchie no longer complains when the open brace is followed by a close tag -- This makes the sniff more useful when used in templates -- Thanks to Joseph Zidell for the patch - Fixed bug #1782 : Incorrect detection of operator in ternary + anonymous function 3.2.0 3.2.0 stable stable 2017-12-13 BSD License - This release deprecates the @codingStandards comment syntax used for sending commands to PHP_CodeSniffer -- The existing syntax will continue to work in all version 3 releases, but will be removed in version 4 -- The comment formats have been replaced by a shorter syntax: --- @codingStandardsIgnoreFile becomes phpcs:ignoreFile --- @codingStandardsIgnoreStart becomes phpcs:disable --- @codingStandardsIgnoreEnd becomes phpcs:enable --- @codingStandardsIgnoreLine becomes phpcs:ignore --- @codingStandardsChangeSetting becomes phpcs:set -- The new syntax allows for additional developer comments to be added after a -- separator --- This is useful for describing why a code block is being ignored, or why a setting is being changed --- E.g., phpcs:disable -- This code block must be left as-is. -- Comments using the new syntax are assigned new comment token types to allow them to be detected: --- phpcs:ignoreFile has the token T_PHPCS_IGNORE_FILE --- phpcs:disable has the token T_PHPCS_DISABLE --- phpcs:enable has the token T_PHPCS_ENABLE --- phpcs:ignore has the token T_PHPCS_IGNORE --- phpcs:set has the token T_PHPCS_SET - The phpcs:disable and phpcs:ignore comments can now selectively ignore specific sniffs (request #604) -- E.g., phpcs:disable Generic.Commenting.Todo.Found for a specific message -- E.g., phpcs:disable Generic.Commenting.Todo for a whole sniff -- E.g., phpcs:disable Generic.Commenting for a whole category of sniffs -- E.g., phpcs:disable Generic for a whole standard -- Multiple sniff codes can be specified by comma separating them --- E.g., phpcs:disable Generic.Commenting.Todo,PSR1.Files - @codingStandardsIgnoreLine comments now only ignore the following line if they are on a line by themselves -- If they are at the end of an existing line, they will only ignore the line they are on -- Stops some lines from accidentally being ignored -- Same rule applies for the new phpcs:ignore comment syntax - PSR1.Files.SideEffects now respects the new phpcs:disable comment syntax -- The sniff will no longer check any code that is between phpcs:disable and phpcs:enable comments -- The sniff does not support phpcs:ignore; you must wrap code structures with disable/enable comments -- Previously, there was no way to have this sniff ignore parts of a file - Fixed a problem where PHPCS would sometimes hang waiting for STDIN, or read incomplete versions of large files -- Thanks to Arne Jørgensen for the patch - Array properties specified in ruleset files now have their keys and values trimmed -- This saves having to do this in individual sniffs and stops errors introduced by whitespace in rulesets -- Thanks to Juliette Reinders Folmer for the patch - Added phpcs.xsd to allow validation of ruleset XML files -- Thanks to Renaat De Muynck for the contribution - File paths specified using --stdin-path can now point to fake file locations (request #1488) -- Previously, STDIN files using fake file paths were excluded from checking - Setting an empty basepath (--basepath=) on the CLI will now clear a basepath set directly in a ruleset -- Thanks to Xaver Loppenstedt for the patch - Ignore patterns are now checked on symlink target paths instead of symlink source paths -- Restores previous behaviour of this feature - Metrics were being double counted when multiple sniffs were recording the same metric - Added support for bash process substitution -- Thanks to Scott Dutton for the contribution - Files included in the cache file code hash are now sorted to aid in cache file reuse across servers - Windows BAT files can now be used outside a PEAR install -- You must have the path to PHP set in your PATH environment variable -- Thanks to Joris Debonnet for the patch - The JS unsigned right shift assignment operator is now properly classified as an assignment operator -- Thanks to Juliette Reinders Folmer for the patch - The AbstractVariableSniff abstract sniff now supports anonymous classes and nested functions -- Also fixes an issue with Squiz.Scope.MemberVarScope where member vars of anonymous classes were not being checked - Added AbstractArraySniff to make it easier to create sniffs that check array formatting -- Allows for checking of single and multi line arrays easily -- Provides a parsed structure of the array including positions of keys, values, and double arrows - Added Generic.Arrays.ArrayIndent to enforce a single tab stop indent for array keys in multi-line arrays -- Also ensures the close brace is on a new line and indented to the same level as the original statement -- Allows for the indent size to be set using an "indent" property of the sniff - Added Generic.PHP.DiscourageGoto to warn about the use of the GOTO language construct -- Thanks to Juliette Reinders Folmer for the contribution - Generic.Debug.ClosureLinter was not running the gjslint command -- Thanks to Michał Bundyra for the patch - Generic.WhiteSpace.DisallowSpaceIndent now fixes space indents in multi-line block comments -- Thanks to Juliette Reinders Folmer for the patch - Generic.WhiteSpace.DisallowSpaceIndent now fixes mixed space/tab indents more accurately -- Thanks to Juliette Reinders Folmer for the patch - Generic.WhiteSpace.DisallowTabIndent now fixes tab indents in multi-line block comments -- Thanks to Juliette Reinders Folmer for the patch - PEAR.Functions.FunctionDeclaration no longer errors when a function declaration is the first content in a JS file -- Thanks to Juliette Reinders Folmer for the patch - PEAR.Functions.FunctionCallSignature now requires the function name to be indented to an exact tab stop -- If the function name is not the start of the statement, the opening statement must be indented correctly instead -- Added a new fixable error code PEAR.Functions.FunctionCallSignature.OpeningIndent for this error - Squiz.Functions.FunctionDeclarationArgumentSpacing is no longer confused about comments in function declarations -- Thanks to Juliette Reinders Folmer for the patch - Squiz.PHP.NonExecutableCode error messages now indicate which line the code block ending is on -- Makes it easier to identify where the code block exited or returned -- Thanks to Juliette Reinders Folmer for the patch - Squiz.Commenting.FunctionComment now supports nullable type hints - Squiz.Commenting.FunctionCommentThrowTag no longer assigns throw tags inside anon classes to the enclosing function - Squiz.WhiteSpace.SemicolonSpacing now ignores semicolons used for empty statements inside FOR conditions -- Thanks to Juliette Reinders Folmer for the patch - Squiz.ControlStructures.ControlSignature now allows configuring the number of spaces before the colon in alternative syntax -- Override the 'requiredSpacesBeforeColon' setting in a ruleset.xml file to change -- Default remains at 1 -- Thanks to Nikola Kovacs for the patch - The Squiz standard now ensures array keys are indented 4 spaces from the main statement -- Previously, this standard aligned keys 1 space from the start of the array keyword - The Squiz standard now ensures array end braces are aligned with the main statement -- Previously, this standard aligned the close brace with the start of the array keyword - The standard for PHP_CodeSniffer itself now enforces short array syntax - The standard for PHP_CodeSniffer itself now uses the Generic.Arrays/ArrayIndent sniff rules - Improved fixer conflicts and syntax error handling for a number of sniffs -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #1462 : Error processing cyrillic strings in Tokenizer - Fixed bug #1573 : Squiz.WhiteSpace.LanguageConstructSpacing does not properly check for tabs and newlines -- Thanks to Michał Bundyra for the patch - Fixed bug #1590 : InlineControlStructure CBF issue while adding braces to an if thats returning a nested function - Fixed bug #1718 : Unclosed strings at EOF sometimes tokenized as T_WHITESPACE by the JS tokenizer - Fixed bug #1731 : Directory exclusions do not work as expected when a single file name is passed to phpcs - Fixed bug #1737 : Squiz.CSS.EmptyStyleDefinition sees comment as style definition and fails to report error - Fixed bug #1746 : Very large reports can sometimes become garbled when using the parallel option - Fixed bug #1747 : Squiz.Scope.StaticThisUsage incorrectly looking inside closures - Fixed bug #1757 : Unknown type hint "object" in Squiz.Commenting.FunctionComment - Fixed bug #1758 : PHPCS gets stuck creating file list when processing circular symlinks - Fixed bug #1761 : Generic.WhiteSpace.ScopeIndent error on multi-line function call with static closure argument - Fixed bug #1762 : Generic.WhiteSpace.Disallow[Space/Tab]Indent not inspecting content before open tag -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #1769 : Custom "define" function triggers a warning about declaring new symbols - Fixed bug #1776 : Squiz.Scope.StaticThisUsage incorrectly looking inside anon classes - Fixed bug #1777 : Generic.WhiteSpace.ScopeIndent incorrect indent errors when self called function proceeded by comment 3.1.1 3.1.1 stable stable 2017-10-17 BSD License - Restored preference of non-dist files over dist files for phpcs.xml and phpcs.xml.dist -- The order that the files are searched is now: .phpcs.xml, phpcs.xml, .phpcs.xml.dist, phpcs.xml.dist -- Thanks to Juliette Reinders Folmer for the patch - Progress output now correctly shows skipped files - Progress output now shows 100% when the file list has finished processing (request #1697) - Stopped some IDEs complaining about testing class aliases -- Thanks to Vytautas Stankus for the patch - Squiz.Commenting.InlineComment incorrectly identified comment blocks in some cases, muting some errors -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #1512 : PEAR.Functions.FunctionCallSignature enforces spaces when no arguments if required spaces is not 0 - Fixed bug #1522 : Squiz Arrays.ArrayDeclaration and Strings.ConcatenationSpacing fixers causing parse errors with here/ nowdocs - Fixed bug #1570 : Squiz.Arrays.ArrayDeclaration fixer removes comments between array keyword and open parentheses - Fixed bug #1604 : File::isReference has problems with some bitwise operators and class property references -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #1645 : Squiz.Commenting.InlineComment will fail to fix comments at the end of the file -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #1656 : Using the --sniffs argument has a problem with case sensitivity - Fixed bug #1657 : Uninitialized string offset: 0 when sniffing CSS - Fixed bug #1669 : Temporary expression proceeded by curly brace is detected as function call - Fixed bug #1681 : Huge arrays are super slow to scan with Squiz.Arrays.ArrayDeclaration sniff - Fixed bug #1694 : Squiz.Arrays.ArrayBracketSpacing is removing some comments during fixing -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #1702 : Generic.WhiteSpaceDisallowSpaceIndent fixer bug when line only contains superfluous whitespace 3.1.0 3.1.0 stable stable 2017-09-20 BSD License - This release includes a change to support newer versions of PHPUnit (versions 4, 5, and 6 are now supported) -- The custom PHP_CodeSniffer test runner now requires a bootstrap file -- Developers with custom standards using the PHP_CodeSniffer test runner will need to do one of the following: --- run your unit tests from the PHP_CodeSniffer root dir so the bootstrap file is included --- specify the PHP_CodeSniffer bootstrap file on the command line: phpunit --bootstrap=/path/to/phpcs/tests/bootstrap.php --- require the PHP_CodeSniffer bootstrap file from your own bootstrap file -- If you don't run PHP_CodeSniffer unit tests, this change will not affect you -- Thanks to Juliette Reinders Folmer for the patch - A phpcs.xml or phpcs.xml.dist file now takes precedence over the default_standard config setting -- Thanks to Björn Fischer for the patch - Both phpcs.xml and phpcs.xml.dist files can now be prefixed with a dot (request #1566) -- The order that the files are searched is: .phpcs.xml, .phpcs.xml.dist, phpcs.xml, phpcs.xml.dist - The autoloader will now search for files during unit tests runs from the same locations as during normal phpcs runs -- Allows for easier unit testing of custom standards that use helper classes or custom namespaces - Include patterns for sniffs now use OR logic instead of AND logic -- Previously, a file had to be in each of the include patterns to be processed by a sniff -- Now, a file has to only be in at least one of the patterns -- This change reflects the original intention of the feature - PHPCS will now follow symlinks under the list of checked directories -- This previously only worked if you specified the path to a symlink on the command line - Output from --config-show, --config-set, and --config-delete now includes the path to the loaded config file - PHPCS now cleanly exits if its config file is not readable -- Previously, a combination of PHP notices and PHPCS errors would be generated - Comment tokens that start with /** are now always tokenized as docblocks -- Thanks to Michał Bundyra for the patch - The PHP-supplied T_YIELD and T_YIELD_FROM token have been replicated for older PHP versions -- Thanks to Michał Bundyra for the patch - Added new Generic.CodeAnalysis.AssignmentInCondition sniff to warn about variable assignments inside conditions -- Thanks to Juliette Reinders Folmer for the contribution - Added Generic.Files.OneObjectStructurePerFile sniff to ensure there is a single class/interface/trait per file -- Thanks to Mponos George for the contribution - Function call sniffs now check variable function names and self/static object creation -- Specific sniffs are Generic.Functions.FunctionCallArgumentSpacing, PEAR.Functions.FunctionCallSignature, and PSR2.Methods.FunctionCallSignature -- Thanks to Michał Bundyra for the patch - Generic.Files.LineLength can now be configured to ignore all comment lines, no matter their length -- Set the ignoreComments property to TRUE (default is FALSE) in your ruleset.xml file to enable this -- Thanks to Juliette Reinders Folmer for the patch - Generic.PHP.LowerCaseKeyword now checks self, parent, yield, yield from, and closure (function) keywords -- Thanks to Michał Bundyra for the patch - PEAR.Functions.FunctionDeclaration now removes a blank line if it creates one by moving the curly brace during fixing - Squiz.Commenting.FunctionCommentThrowTag now supports PHP 7.1 multi catch exceptions - Squiz.Formatting.OperatorBracket no longer throws errors for PHP 7.1 multi catch exceptions - Squiz.Commenting.LongConditionClosingComment now supports finally statements - Squiz.Formatting.OperatorBracket now correctly fixes pipe separated flags - Squiz.Formatting.OperatorBracket now correctly fixes statements containing short array syntax - Squiz.PHP.EmbeddedPhp now properly fixes cases where the only content in an embedded PHP block is a comment -- Thanks to Juliette Reinders Folmer for the patch - Squiz.WhiteSpace.ControlStructureSpacing now ignores comments when checking blank lines at the top of control structures - Squiz.WhiteSpace.ObjectOperatorSpacing now detects and fixes spaces around double colons -- Thanks to Julius Šmatavičius for the patch - Squiz.WhiteSpace.MemberVarSpacing can now be configured to check any number of blank lines between member vars -- Set the spacing property (default is 1) in your ruleset.xml file to set the spacing - Squiz.WhiteSpace.MemberVarSpacing can now be configured to check a different number of blank lines before the first member var -- Set the spacingBeforeFirst property (default is 1) in your ruleset.xml file to set the spacing - Added a new PHP_CodeSniffer\Util\Tokens::$ooScopeTokens static member var for quickly checking object scope -- Includes T_CLASS, T_ANON_CLASS, T_INTERFACE, and T_TRAIT -- Thanks to Juliette Reinders Folmer for the patch - PHP_CodeSniffer\Files\File::findExtendedClassName() now supports extended interfaces -- Thanks to Martin Hujer for the patch - Fixed bug #1550 : Squiz.Commenting.FunctionComment false positive when function contains closure - Fixed bug #1577 : Generic.InlineControlStructureSniff breaks with a comment between body and condition in do while loops - Fixed bug #1581 : Sniffs not loaded when one-standard directories are being registered in installed_paths - Fixed bug #1591 : Autoloader failing to load arbitrary files when installed_paths only set via a custom ruleset - Fixed bug #1605 : Squiz.WhiteSpace.OperatorSpacing false positive on unary minus after comment -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #1615 : Uncaught RuntimeException when phpcbf fails to fix files - Fixed bug #1637 : Generic.WhiteSpaceScopeIndent closure argument indenting incorrect with multi-line strings - Fixed bug #1638 : Squiz.WhiteSpace.ScopeClosingBrace closure argument indenting incorrect with multi-line strings - Fixed bug #1640 : Squiz.Strings.DoubleQuoteUsage replaces tabs with spaces when fixing -- Thanks to Juliette Reinders Folmer for the patch 3.0.2 3.0.2 stable stable 2017-07-18 BSD License - Fixed a problem where the source report was not printing the correct number of errors found - Fixed a problem where the --cache=/path/to/cachefile CLI argument was not working - The code report now gracefully handles tokenizer exceptions - The phpcs and phpcbf scripts and now the only places that exit() in the code -- This allows for easier usage of core PHPCS functions from external scripts -- If you are calling Runner::runPHPCS() or Runner::runPHPCBF() directly, you will get back the full range of exit codes -- If not, catch the new DeepExitException to get the error message ($e->getMessage()) and exit code ($e->getCode()); - NOWDOC tokens are now considered conditions, just as HEREDOC tokens are -- This makes it easier to find the start and end of a NOWDOC from any token within it -- Thanks to Michał Bundyra for the patch - Custom autoloaders are now only included once in case multiple standards are using the same one -- Thanks to Juliette Reinders Folmer for the patch - Improved tokenizing of fallthrough CASE and DEFAULT statements that share a closing statement and use curly braces - Improved the error message when Squiz.ControlStructures.ControlSignature detects a newline after the closing parenthesis - Fixed bug #1465 : Generic.WhiteSpace.ScopeIndent reports incorrect errors when indenting double arrows in short arrays - Fixed bug #1478 : Indentation in fallthrough CASE that contains a closure - Fixed bug #1497 : Fatal error if composer prepend-autoloader is set to false -- Thanks to Kunal Mehta for the patch - Fixed bug #1503 : Alternative control structure syntax not always recognized as scoped - Fixed bug #1523 : Fatal error when using the --suffix argument -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #1526 : Use of basepath setting can stop PHPCBF being able to write fixed files - Fixed bug #1530 : Generic.WhiteSpace.ScopeIndent can increase indent too much for lines within code blocks - Fixed bug #1547 : Wrong token type for backslash in use function -- Thanks to Michał Bundyra for the patch - Fixed bug #1549 : Squiz.PHP.EmbeddedPhp fixer conflict with // comment before PHP close tag -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #1560 : Squiz.Commenting.FunctionComment fatal error when fixing additional param comment lines that have no indent 3.0.1 3.0.1 stable stable 2017-06-14 BSD License - This release contains a fix for a security advisory related to the improper handling of a shell command -- A properly crafted filename would allow for arbitrary code execution when using the --filter=gitmodified command line option -- All version 3 users are encouraged to upgrade to this version, especially if you are checking 3rd-party code --- e.g., you run PHPCS over libraries that you did not write --- e.g., you provide a web service that runs PHPCS over user-uploaded files or 3rd-party repositories --- e.g., you allow external tool paths to be set by user-defined values -- If you are unable to upgrade but you check 3rd-party code, ensure you are not using the Git modified filter -- This advisory does not affect PHP_CodeSniffer version 2. -- Thanks to Sergei Morozov for the report and patch - Arguments on the command line now override or merge with those specified in a ruleset.xml file in all cases - PHPCS now stops looking for a phpcs.xml file as soon as one is found, favoring the closest one to the current dir - Added missing help text for the --stdin-path CLI option to --help - Re-added missing help text for the --file-list and --bootstrap CLI options to --help - Runner::runPHPCS() and Runner::runPHPCBF() now return an exit code instead of exiting directly (request #1484) - The Squiz standard now enforces short array syntax by default - The autoloader is now working correctly with classes created with class_alias() - The autoloader will now search for files inside all directories in the installed_paths config var -- This allows autoloading of files inside included custom coding standards without manually requiring them - You can now specify a namespace for a custom coding standard, used by the autoloader to load non-sniff helper files -- Also used by the autoloader to help other standards directly include sniffs for your standard -- Set the value to the namespace prefix you are using for sniff files (everything up to \Sniffs\) -- e.g., if your namespace format is MyProject\CS\Standard\Sniffs\Category set the namespace to MyProject\CS\Standard -- If omitted, the namespace is assumed to be the same as the directory name containing the ruleset.xml file -- The namespace is set in the ruleset tag of the ruleset.xml file -- e.g., ruleset name="My Coding Standard" namespace="MyProject\CS\Standard" - Rulesets can now specify custom autoloaders using the new autoload tag -- Autoloaders are included while the ruleset is being processed and before any custom sniffs are included -- Allows for very custom autoloading of helper classes well before the boostrap files are included - The PEAR standard now includes Squiz.Commenting.DocCommentAlignment -- It previously broke comments onto multiple lines, but didn't align them - Fixed a problem where excluding a message from a custom standard's own sniff would exclude the whole sniff -- This caused some PSR2 errors to be under-reported - Fixed bug #1442 : T_NULLABLE detection not working for nullable parameters and return type hints in some cases - Fixed bug #1447 : Running the unit tests with a phpunit config file breaks the test suite -- Unknown arguments were not being handled correctly, but are now stored in $config->unknown - Fixed bug #1449 : Generic.Classes.OpeningBraceSameLine doesn't detect comment before opening brace -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #1450 : Coding standard located under an installed_path with the same directory name throws an error -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #1451 : Sniff exclusions/restrictions dont work with custom sniffs unless they use the PHP_CodeSniffer NS - Fixed bug #1454 : Squiz.WhiteSpace.OperatorSpacing is not checking spacing on either side of a short ternary operator -- Thanks to Mponos George for the patch - Fixed bug #1495 : Setting an invalid installed path breaks all commands - Fixed bug #1496 : Squiz.Strings.DoubleQuoteUsage not unescaping dollar sign when fixing -- Thanks to Michał Bundyra for the patch - Fixed bug #1501 : Interactive mode is broken - Fixed bug #1504 : PSR2.Namespaces.UseDeclaration hangs fixing use statement with no trailing code 2.9.1 2.9.1 stable stable 2017-05-22 BSD License - Fixed bug #1442 : T_NULLABLE detection not working for nullable parameters and return type hints in some cases - Fixed bug #1448 : Generic.Classes.OpeningBraceSameLine doesn't detect comment before opening brace -- Thanks to Juliette Reinders Folmer for the patch 3.0.0 3.0.0 stable stable 2017-05-04 BSD License - Added an --ignore-annotations command line argument to ignore all @codingStandards annotations in code comments (request #811) -- This allows you to force errors to be shown that would otherwise be ignored by code comments -- Also stop files being able to change sniff properties mid way through processing - An error is now reported if no sniffs were registered to be run (request #1129) - The autoloader will now search for files inside the directory of any loaded coding standard -- This allows autoloading of any file inside a custom coding standard without manually requiring them -- Ensure your namespace begins with your coding standard's directory name and follows PSR-4 -- e.g., StandardName\Sniffs\CategoryName\AbstractHelper or StandardName\Helpers\StringSniffHelper - Fixed an error where STDIN was sometimes not checked when using the --parallel CLI option - The is_closure index has been removed from the return value of File::getMethodProperties() -- This value was always false because T_FUNCTION tokens are never closures -- Closures have a token type of T_CLOSURE - The File::isAnonymousFunction() method has been removed -- This function always returned false because it only accepted T_FUNCTION tokens, which are never closures -- Closures have a token type of T_CLOSURE - Includes all changes from the 2.9.0 release - Fixed bug #834 : PSR2.ControlStructures.SwitchDeclaration does not handle if branches with returns -- Thanks to Fabian Wiget for the patch 3.0.0RC4 3.0.0RC4 beta beta 2017-03-02 BSD License - This release contains a fix for a security advisory related to the improper handling of shell commands -- Uses of shell_exec() and exec() were not escaping filenames and configuration settings in most cases -- A properly crafted filename or configuration option would allow for arbitrary code execution when using some features -- All users are encouraged to upgrade to this version, especially if you are checking 3rd-party code --- e.g., you run PHPCS over libraries that you did not write --- e.g., you provide a web service that runs PHPCS over user-uploaded files or 3rd-party repositories --- e.g., you allow external tool paths to be set by user-defined values -- If you are unable to upgrade but you check 3rd-party code, ensure you are not using the following features: --- The diff report --- The notify-send report --- The Generic.PHP.Syntax sniff --- The Generic.Debug.CSSLint sniff --- The Generic.Debug.ClosureLinter sniff --- The Generic.Debug.JSHint sniff --- The Squiz.Debug.JSLint sniff --- The Squiz.Debug.JavaScriptLint sniff --- The Zend.Debug.CodeAnalyzer sniff -- Thanks to Klaus Purer for the report - The indent property of PEAR.Classes.ClassDeclaration has been removed -- Instead of calculating the indent of the brace, it just ensures the brace is aligned with the class keyword -- Other sniffs can be used to ensure the class itself is indented correctly - Invalid exclude rules inside a ruleset.xml file are now ignored instead of potentially causing out of memory errors -- Using the -vv command line argument now also shows the invalid exclude rule as XML - Includes all changes from the 2.8.1 release - Fixed bug #1333 : The new autoloader breaks some frameworks with custom autoloaders - Fixed bug #1334 : Undefined offset when explaining standard with custom sniffs 3.0.0RC3 3.0.0RC3 beta beta 2017-02-02 BSD License - Added support for ES6 class declarations -- Previously, these class were tokenized as JS objects but are now tokenized as normal T_CLASS structures - Added support for ES6 method declarations, where the "function" keyword is not used -- Previously, these methods were tokenized as JS objects (fixes bug #1251) -- The name of the ES6 method is now assigned the T_FUNCTION keyword and treated like a normal function -- Custom sniffs that support JS and listen for T_FUNCTION tokens can't assume the token represents the word "function" -- Check the contents of the token first, or use $phpcsFile->getDeclarationName($stackPtr) if you just want its name -- There is no change for custom sniffs that only check PHP code - PHPCBF exit codes have been changed so they are now more useful (request #1270) -- Exit code 0 is now used to indicate that no fixable errors were found, and so nothing was fixed -- Exit code 1 is now used to indicate that all fixable errors were fixed correctly -- Exit code 2 is now used to indicate that PHPCBF failed to fix some of the fixable errors it found -- Exit code 3 is now used for general script execution errors - Added PEAR.Commenting.FileComment.ParamCommentAlignment to check alignment of multi-line param comments - Includes all changes from the 2.8.0 release - Fixed an issue where excluding a file using a @codingStandardsIgnoreFile comment would produce errors -- For PHPCS, it would show empty files being processed -- For PHPCBF, it would produce a PHP error - Fixed bug #1233 : Can't set config data inside ruleset.xml file - Fixed bug #1241 : CodeSniffer.conf not working with 3.x PHAR file 3.0.0RC2 3.0.0RC2 beta beta 2016-11-30 BSD License - Fixed an undefined var name error that could be produced while running PHPCBF - Made the Runner class easier to use with wrapper scripts - Full usage information is no longer printed when a usage error is encountered (request #1186) -- Makes it a lot easier to find and read the error message that was printed - Includes all changes from the 2.7.1 release - Fixed bug #1167 : 3.0.0RC1 PHAR does not work with PEAR standard - Fixed bug #1208 : Excluding files doesn't work when using STDIN with a filename specified 3.0.0RC1 3.0.0RC1 beta beta 2016-09-02 BSD License - Progress output now shows E and W in green when a file has fixable errors or warnings -- Only supported if colors are enabled - PHPCBF no longer produces verbose output by default (request #699) -- Use the -v command line argument to show verbose fixing output -- Use the -q command line argument to disable verbose information if enabled by default - PHPBF now prints a summary report after fixing files -- Report shows files that were fixed, how many errors were fixed, and how many remain - PHPCBF now supports the -p command line argument to print progress information -- Prints a green F for files where fixes occurred -- Prints a red E for files that could not be fixed due to an error -- Use the -q command line argument to disable progress information if enabled by default - Running unit tests using --verbose no longer throws errors - Fixed shell error appearing on some systems when trying to find executable paths - Includes all changes from the 2.7.0 release 3.0.0a1 3.0.0a1 alpha alpha 2016-07-20 BSD License - Min PHP version increased from 5.1.2 to 5.4.0 - Added optional caching of results between runs (request #530) -- Enable the cache by using the --cache command line argument -- If you want the cache file written somewhere specific, use --cache=/path/to/cacheFile -- Use the command "phpcs --config-set cache true" to turn caching on by default -- Use the --no-cache command line argument to disable caching if it is being turned on automatically - Add support for checking file in parallel (request #421) -- Tell PHPCS how many files to check at once using the --parallel command line argument -- To check 100 files at once, using --parallel=100 -- To disable parallel checking if it is being turned on automatically, use --parallel=1 -- Requires PHP to be compiled with the PCNTL package - The default encoding has been changed from iso-8859-1 to utf-8 (request #760) -- The --encoding command line argument still works, but you no longer have to set it to process files as utf-8 -- If encoding is being set to utf-8 in a ruleset or on the CLI, it can be safely removed -- If the iconv PHP extension is not installed, standard non-multibyte aware functions will be used - Added a new "code" report type to show a code snippet for each error (request #419) -- The line containing the error is printed, along with 2 lines above and below it to show context -- The location of the errors is underlined in the code snippet if you also use --colors -- Use --report=code to generate this report - Added support for custom filtering of the file list -- Developers can write their own filter classes to perform custom filtering of the list before the run starts -- Use the command line arg --filter=/path/to/filter.php to specify a filter to use -- Extend \PHP_CodeSniffer\Filters\Filter to also support the core PHPCS extension and path filtering -- Extend \PHP_CodeSniffer\Filters\ExactMatch to get the core filtering and the ability to use blacklists and whitelists -- The included \PHP_CodeSniffer\Filters\GitModified filter is a good example of an ExactMatch filter - Added support for only checking files that have been locally modified or added in a git repo -- Use --filter=gitmodified to check these files -- You still need to give PHPCS a list of files or directories in which to check - Added automatic discovery of executable paths (request #571) -- Thanks to Sergey Morozov for the patch - You must now pass "-" on the command line to have PHPCS wait for STDIN -- E.g., phpcs --standard=PSR2 - -- You can still pipe content via STDIN as normal as PHPCS will see this and process it -- But without the "-", PHPCS will throw an error if no content or files are passed to it - All PHP errors generated by sniffs are caught, re-thrown as exceptions, and reported in the standard error reports -- This should stop bugs inside sniffs causing infinite loops -- Also stops invalid reports being produced as errors don't print to the screen directly - Sniff codes are no longer optional -- If a sniff throws and error or a warning, it must specify an internal code for that message - The installed_paths config setting can now point directly to a standard -- Previously, it had to always point to the directory in which the standard lives - Multiple reports can now be specified using the --report command line argument -- Report types are separated by commas -- E.g., --report=full,summary,info -- Previously, you had to use one argument for each report such as --report=full --report=summary --report=info - You can now set the severity, message type, and exclude patterns for and entire sniff, category, or standard -- Previously, this was only available for a single message - You can now include a single sniff code in a ruleset instead of having to include an entire sniff -- Including a sniff code will automatically exclude all other messages from that sniff -- If the sniff is already included by an imported standard, set the sniff severity to 0 and include the specific message you want - PHPCBF no longer uses patch -- Files are now always overwritten -- The --no-patch option has been removed - Added a --basepath option to strip a directory from the front of file paths in output (request #470) -- The basepath is absolute or relative to the current directory -- E.g., to output paths relative to current dir in reports, use --basepath=. - Ignore rules are now checked when using STDIN (request #733) - Added an include-pattern tag to rulesets to include a sniff for specific files and folders only (request #656) -- This is the exact opposite of the exclude-pattern tag -- This option is only usable within sniffs, not globally like exclude-patterns are - Added a new -m option to stop error messages from being recorded, which saves a lot of memory -- PHPCBF always uses this setting to reduce memory as it never outputs error messages -- Setting the $recordErrors member var inside custom report classes is no longer supported (use -m instead) - Exit code 2 is now used to indicate fixable errors were found (request #930) -- Exit code 3 is now used for general script execution errors -- Exit code 1 is used to indicate that coding standard errors were found, but none are fixable -- Exit code 0 is unchanged and continues to mean no coding standard errors found - The included PHPCS standard has been removed -- All rules are now found inside the phpcs.xml.dist file -- Running "phpcs" without any arguments from a git clone will use this ruleset - The included SVN pre-commit hook has been removed -- Hooks for version control systems will no longer be maintained within the PHPCS project 2.9.0 2.9.0 stable stable 2017-05-04 BSD License - Added Generic.Debug.ESLint sniff to run ESLint over JS files and report errors -- Set eslint path using: phpcs --config-set eslint_path /path/to/eslint -- Thanks to Ryan McCue for the contribution - T_POW is now properly considered an arithmetic operator, and will be checked as such -- Thanks to Juliette Reinders Folmer for the patch - T_SPACESHIP and T_COALESCE are now properly considered comparison operators, and will be checked as such -- Thanks to Juliette Reinders Folmer for the patch - Generic.PHP.DisallowShortOpenTag now warns about possible short open tags even when short_open_tag is set to OFF -- Thanks to Juliette Reinders Folmer for the patch - Generic.WhiteSpace.DisallowTabIndent now finds and fixes improper use of spaces anywhere inside the line indent -- Previously, only the first part of the indent was used to determine the indent type -- Thanks to Juliette Reinders Folmer for the patch - PEAR.Commenting.ClassComment now supports checking of traits as well as classes and interfaces -- Thanks to Juliette Reinders Folmer for the patch - Squiz.Commenting.FunctionCommentThrowTag now supports re-throwing exceptions (request #946) -- Thanks to Samuel Levy for the patch - Squiz.PHP.DisallowMultipleAssignments now ignores PHP4-style member var assignments -- Thanks to Juliette Reinders Folmer for the patch - Squiz.WhiteSpace.FunctionSpacing now ignores spacing above functions when they are preceded by inline comments -- Stops conflicts between this sniff and comment spacing sniffs - Squiz.WhiteSpace.OperatorSpacing no longer checks the equal sign in declare statements -- Thanks to Juliette Reinders Folmer for the patch - Added missing error codes for a couple of sniffs so they can now be customised as normal - Fixed bug #1266 : PEAR.WhiteSpace.ScopeClosingBrace can throw an error while fixing mixed PHP/HTML - Fixed bug #1364 : Yield From values are not recognised as returned values in Squiz FunctionComment sniff - Fixed bug #1373 : Error in tab expansion results in white-space of incorrect size -- Thanks to Mark Clements for the patch - Fixed bug #1381 : Tokenizer: dereferencing incorrectly identified as short array - Fixed bug #1387 : Squiz.ControlStructures.ControlSignature does not handle alt syntax when checking space after closing brace - Fixed bug #1392 : Scope indent calculated incorrectly when using array destructuring - Fixed bug #1394 : integer type hints appearing as TypeHintMissing instead of ScalarTypeHintMissing -- PHP 7 type hints were also being shown when run under PHP 5 in some cases - Fixed bug #1405 : Squiz.WhiteSpace.ScopeClosingBrace fails to fix closing brace within indented PHP tags - Fixed bug #1421 : Ternaries used in constant scalar expression for param default misidentified by tokenizer - Fixed bug #1431 : PHPCBF can't fix short open tags when they are not followed by a space -- Thanks to Gonçalo Queirós for the patch - Fixed bug #1432 : PHPCBF can make invalid fixes to inline JS control structures that make use of JS objects 2.8.1 2.8.1 stable stable 2017-03-02 BSD License - This release contains a fix for a security advisory related to the improper handling of shell commands -- Uses of shell_exec() and exec() were not escaping filenames and configuration settings in most cases -- A properly crafted filename or configuration option would allow for arbitrary code execution when using some features -- All users are encouraged to upgrade to this version, especially if you are checking 3rd-party code --- e.g., you run PHPCS over libraries that you did not write --- e.g., you provide a web service that runs PHPCS over user-uploaded files or 3rd-party repositories --- e.g., you allow external tool paths to be set by user-defined values -- If you are unable to upgrade but you check 3rd-party code, ensure you are not using the following features: --- The diff report --- The notify-send report --- The Generic.PHP.Syntax sniff --- The Generic.Debug.CSSLint sniff --- The Generic.Debug.ClosureLinter sniff --- The Generic.Debug.JSHint sniff --- The Squiz.Debug.JSLint sniff --- The Squiz.Debug.JavaScriptLint sniff --- The Zend.Debug.CodeAnalyzer sniff -- Thanks to Klaus Purer for the report - The PHP-supplied T_COALESCE_EQUAL token has been replicated for PHP versions before 7.2 - PEAR.Functions.FunctionDeclaration now reports an error for blank lines found inside a function declaration - PEAR.Functions.FunctionDeclaration no longer reports indent errors for blank lines in a function declaration - Squiz.Functions.MultiLineFunctionDeclaration no longer reports errors for blank lines in a function declaration -- It would previously report that only one argument is allowed per line - Squiz.Commenting.FunctionComment now corrects multi-line param comment padding more accurately - Squiz.Commenting.FunctionComment now properly fixes pipe-separated param types - Squiz.Commenting.FunctionComment now works correctly when function return types also contain a comment -- Thanks to Juliette Reinders Folmer for the patch - Squiz.ControlStructures.InlineIfDeclaration now supports the elvis operator -- As this is not a real PHP operator, it enforces no spaces between ? and : when the THEN statement is empty - Squiz.ControlStructures.InlineIfDeclaration is now able to fix the spacing errors it reports - Fixed bug #1340 : STDIN file contents not being populated in some cases -- Thanks to David Biňovec for the patch - Fixed bug #1344 : PEAR.Functions.FunctionCallSignatureSniff throws error for blank comment lines - Fixed bug #1347 : PSR2.Methods.FunctionCallSignature strips some comments during fixing -- Thanks to Algirdas Gurevicius for the patch - Fixed bug #1349 : Squiz.Strings.DoubleQuoteUsage.NotRequired message is badly formatted when string contains a CR newline char -- Thanks to Algirdas Gurevicius for the patch - Fixed bug #1350 : Invalid Squiz.Formatting.OperatorBracket error when using namespaces - Fixed bug #1369 : Empty line in multi-line function declaration cause infinite loop 2.8.0 2.8.0 stable stable 2017-02-02 BSD License - The Internal.NoCodeFound error is no longer generated for content sourced from STDIN -- This should stop some Git hooks generating errors because PHPCS is trying to process the refs passed on STDIN - Squiz.Commenting.DocCommentAlignment now checks comments on class properties defined using the VAR keyword -- Thanks to Klaus Purer for the patch - The getMethodParameters() method now recognises "self" as a valid type hint -- The return array now contains a new "content" index containing the raw content of the param definition -- Thanks to Juliette Reinders Folmer for the patch - The getMethodParameters() method now supports nullable types -- The return array now contains a new "nullable_type" index set to true or false for each method param -- Thanks to Juliette Reinders Folmer for the patch - The getMethodParameters() method now supports closures -- Thanks to Juliette Reinders Folmer for the patch - Added more guard code for JS files with syntax errors (request #1271 and request #1272) - Added more guard code for CSS files with syntax errors (request #1304) - PEAR.Commenting.FunctionComment fixers now correctly handle multi-line param comments - AbstractVariableSniff now supports anonymous classes -- Thanks to Juliette Reinders Folmer for the patch - Generic.NamingConventions.ConstructorName and PEAR.NamingConventions.ValidVariable now support anonymous classes - Generic.NamingConventions.CamelCapsFunctionName and PEAR.NamingConventions.ValidFunctionName now support anonymous classes -- Thanks to Juliette Reinders Folmer for the patch - Generic.CodeAnalysis.UnusedFunctionParameter and PEAR.Functions.ValidDefaultValue now support closures -- Thanks to Juliette Reinders Folmer for the patch - PEAR.NamingConventions.ValidClassName and Squiz.Classes.ValidClassName now support traits -- Thanks to Juliette Reinders Folmer for the patch - Generic.Functions.FunctionCallArgumentSpacing now supports closures other PHP-provided functions -- Thanks to Algirdas Gurevicius for the patch - Fixed an error where a nullable type character was detected as an inline then token -- A new T_NULLABLE token has been added to represent the ? nullable type character -- Thanks to Jaroslav Hanslík for the patch - Squiz.WhiteSpace.SemicolonSpacing no longer removes comments while fixing the placement of semicolons -- Thanks to Algirdas Gurevicius for the patch - Fixed bug #1230 : JS tokeniser incorrectly tokenises bitwise shifts as comparison -- Thanks to Ryan McCue for the patch - Fixed bug #1237 : Uninitialized string offset in PHP Tokenizer on PHP 5.2 - Fixed bug #1239 : Warning when static method name is 'default' - Fixed bug #1240 : False positive for function names starting with triple underscore -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #1245 : SELF is not recognised as T_SELF token in: return new self - Fixed bug #1246 : A mix of USE statements with and without braces can cause the tokenizer to mismatch brace tokens -- Thanks to Michał Bundyra for the patch - Fixed bug #1249 : GitBlame report requires a .git directory - Fixed bug #1252 : Squiz.Strings.ConcatenationSpacing fix creates syntax error when joining a number to a string - Fixed bug #1253 : Generic.ControlStructures.InlineControlStructure fix creates syntax error fixing if-try/catch - Fixed bug #1255 : Inconsistent indentation check results when ELSE on new line - Fixed bug #1257 : Double dash in CSS class name can lead to "Named colours are forbidden" false positives - Fixed bug #1260 : Syntax errors not being shown when error_prepend_string is set -- Thanks to Juliette Reinders Folmer for the patch - Fixed bug #1264 : Array return type hint is sometimes detected as T_ARRAY_HINT instead of T_RETURN_TYPE -- Thanks to Jaroslav Hanslík for the patch - Fixed bug #1265 : ES6 arrow function raises unexpected operator spacing errors - Fixed bug #1267 : Fixer incorrectly handles filepaths with repeated dir names -- Thanks to Sergey Ovchinnikov for the patch - Fixed bug #1276 : Commenting.FunctionComment.InvalidReturnVoid conditional issue with anonymous classes - Fixed bug #1277 : Squiz.PHP.DisallowMultipleAssignments.Found error when var assignment is on the same line as an open tag - Fixed bug #1284 : Squiz.Arrays.ArrayBracketSpacing.SpaceBeforeBracket false positive match for short list syntax 2.7.1 2.7.1 stable stable 2016-11-30 BSD License - Squiz.ControlStructures.ControlSignature.SpaceAfterCloseParenthesis fix now removes unnecessary whitespace - Squiz.Formatting.OperatorBracket no longer errors for negative array indexes used within a function call - Squiz.PHP.EmbeddedPhp no longer expects a semicolon after statements that are only opening a scope - Fixed a problem where the content of T_DOC_COMMENT_CLOSE_TAG tokens could sometimes be (boolean) false - Developers of custom standards with custom test runners can now have their standards ignored by the built-in test runner -- Set the value of an environment variable called PHPCS_IGNORE_TESTS with a comma separated list of your standard names -- Thanks to Juliette Reinders Folmer for the patch - The unit test runner now loads the test sniff outside of the standard's ruleset so that exclude rules do not get applied -- This may have caused problems when testing custom sniffs inside custom standards -- Also makes the unit tests runs a little faster - The SVN pre-commit hook now works correctly when installed via composer -- Thanks to Sergey for the patch - Fixed bug #1135 : PEAR.ControlStructures.MultiLineCondition.CloseBracketNewLine not detected if preceded by multiline function call - Fixed bug #1138 : PEAR.ControlStructures.MultiLineCondition.Alignment not detected if closing brace is first token on line - Fixed bug #1141 : Sniffs that check EOF newlines don't detect newlines properly when the last token is a doc block - Fixed bug #1150 : Squiz.Strings.EchoedStrings does not properly fix bracketed statements - Fixed bug #1156 : Generic.Formatting.DisallowMultipleStatements errors when multiple short echo tags are used on the same line -- Thanks to Nikola Kovacs for the patch - Fixed bug #1161 : Absolute report path is treated like a relative path if it also exists within the current directory - Fixed bug #1170 : Javascript regular expression literal not recognized after comparison operator - Fixed bug #1180 : Class constant named FUNCTION is incorrectly tokenized - Fixed bug #1181 : Squiz.Operators.IncrementDecrementUsage.NoBrackets false positive when incrementing properties -- Thanks to Jürgen Henge-Ernst for the patch - Fixed bug #1188 : Generic.WhiteSpace.ScopeIndent issues with inline HTML and multi-line function signatures - Fixed bug #1190 : phpcbf on if/else with trailing comment generates erroneous code - Fixed bug #1191 : Javascript sniffer fails with function called "Function" - Fixed bug #1203 : Inconsistent behavior of PHP_CodeSniffer_File::findEndOfStatement - Fixed bug #1218 : CASE conditions using class constants named NAMESPACE/INTERFACE/TRAIT etc are incorrectly tokenized - Fixed bug #1221 : Indented function call with multiple closure arguments can cause scope indent error - Fixed bug #1224 : PHPCBF fails to fix code with heredoc/nowdoc as first argument to a function 2.7.0 2.7.0 stable stable 2016-09-02 BSD License - Added --file-list command line argument to allow a list of files and directories to be specified in an external file -- Useful is you have a generated list of files to check that would be too long for the command line -- File and directory paths are listed one per line -- Usage is: phpcs --file-list=/path/to/file-list ... -- Thanks to Blotzu for the patch - Values set using @codingStandardsChangeSetting comments can now contain spaces - Sniff unit tests can now specify a list of test files instead of letting the runner pick them (request #1078) -- Useful if a sniff needs to exclude files based on the environment, or is checking filenames -- Override the new getTestFiles() method to specify your own list of test files - Generic.Functions.OpeningFunctionBraceKernighanRitchie now ignores spacing for function return types -- The sniff code Generic.Functions.OpeningFunctionBraceKernighanRitchie.SpaceAfterBracket has been removed -- Replaced by Generic.Functions.OpeningFunctionBraceKernighanRitchie.SpaceBeforeBrace -- The new error message is slightly clearer as it indicates that a single space is needed before the brace - Squiz.Commenting.LongConditionClosingComment now allows for the length of a code block to be configured -- Set the lineLimit property (default is 20) in your ruleset.xml file to set the code block length -- When the code block length is reached, the sniff will enforce a closing comment after the closing brace -- Thanks to Juliette Reinders Folmer for the patch - Squiz.Commenting.LongConditionClosingComment now allows for the end comment format to be configured -- Set the commentFormat property (default is "//end %s") in your ruleset.xml file to set the format -- The placeholder %s will be replaced with the type of condition opener, e.g., "//end foreach" -- Thanks to Juliette Reinders Folmer for the patch - Generic.PHPForbiddenFunctions now allows forbidden functions to have mixed case -- Previously, it would only do a strtolower comparison -- Error message now shows what case was found in the code and what the correct case should be -- Thanks to Juliette Reinders Folmer for the patch - Added Generic.Classes.OpeningBraceSameLine to ensure opening brace of class/interface/trait is on the same line as the declaration -- Thanks to Juliette Reinders Folmer for the patch - Added Generic.PHP.BacktickOperator to ban the use of the backtick operator for running shell commands -- Thanks to Juliette Reinders Folmer for the patch - Added Generic.PHP.DisallowAlternativePHPTags to ban the use of alternate PHP tags -- Thanks to Juliette Reinders Folmer for the patch - Squiz.WhiteSpace.LanguageConstructSpacing no longer checks for spaces if parenthesis are being used (request #1062) -- Makes this sniff more compatible with those that check parenthesis spacing of function calls - Squiz.WhiteSpace.ObjectOperatorSpacing now has a setting to ignore newline characters around object operators -- Default remains FALSE, so newlines are not allowed -- Override the "ignoreNewlines" setting in a ruleset.xml file to change -- Thanks to Alex Howansky for the patch - Squiz.Scope.MethodScope now sniffs traits as well as classes and interfaces -- Thanks to Jesse Donat for the patch - PHPCBF is now able to fix Squiz.SelfMemberReference.IncorrectCase errors -- Thanks to Nikola Kovacs for the patch - PHPCBF is now able to fix Squiz.Commenting.VariableComment.IncorrectVarType -- Thanks to Walt Sorensen for the patch - PHPCBF is now able to fix Generic.PHP.DisallowShortOpenTag -- Thanks to Juliette Reinders Folmer for the patch - Improved the formatting of the end brace when auto fixing InlineControlStructure errors (request #1121) - Generic.Functions.OpeningFunctionBraceKernighanRitchie.BraceOnNewLine fix no longer leaves blank line after brace (request #1085) - Generic UpperCaseConstantNameSniff now allows lowercase namespaces in constant definitions -- Thanks to Daniel Schniepp for the patch - Squiz DoubleQuoteUsageSniff is now more tolerant of syntax errors caused by mismatched string tokens - A few sniffs that produce errors based on the current PHP version can now be told to run using a specific PHP version -- Set the php_version config var using --config-set, --runtime-set, or in a ruleset to specify a specific PHP version -- The format of the PHP version is the same as the PHP_VERSION_ID constant (e.g., 50403 for version 5.4.3) -- Supported sniffs are Generic.PHP.DisallowAlternativePHPTags, PSR1.Classes.ClassDeclaration, Squiz.Commenting.FunctionComment -- Thanks to Finlay Beaton for the patch - Fixed bug #985 : Duplicate class definition detection generates false-positives in media queries -- Thanks to Raphael Horber for the patch - Fixed bug #1014 : Squiz VariableCommentSniff doesn't always detect a missing comment - Fixed bug #1066 : Undefined index: quiet in CLI.php during unit test run with -v command line arg - Fixed bug #1072 : Squiz.SelfMemberReference.NotUsed not detected if leading namespace separator is used - Fixed bug #1089 : Rulesets cannot be loaded if the path contains urlencoded characters - Fixed bug #1091 : PEAR and Squiz FunctionComment sniffs throw errors for some invalid @param line formats - Fixed bug #1092 : PEAR.Functions.ValidDefaultValue should not flag type hinted methods with a NULL default argument - Fixed bug #1095 : Generic LineEndings sniff replaces tabs with spaces with --tab-width is set - Fixed bug #1096 : Squiz FunctionDeclarationArgumentSpacing gives incorrect error/fix when variadic operator is followed by a space - Fixed bug #1099 : Group use declarations are incorrectly fixed by the PSR2 standard -- Thanks to Jason McCreary for the patch - Fixed bug #1101 : Incorrect indent errors when breaking out of PHP inside an IF statement - Fixed bug #1102 : Squiz.Formatting.OperatorBracket.MissingBrackets faulty bracketing fix - Fixed bug #1109 : Wrong scope indent reported in anonymous class - Fixed bug #1112 : File docblock not recognized when require_once follows it - Fixed bug #1120 : InlineControlStructureSniff does not handle auto-fixing for control structures that make function calls - Fixed bug #1124 : Squiz.Operators.ComparisonOperatorUsage does not detect bracketed conditions for inline IF statements -- Thanks to Raphael Horber for the patch 2.6.2 2.6.2 stable stable 2016-07-14 BSD License - Added a new --exclude CLI argument to exclude a list of sniffs from checking and fixing (request #904) -- Accepts the same sniff codes as the --sniffs command line argument, but provides the opposite functionality - Added a new -q command line argument to disable progress and verbose information from being printed (request #969) -- Useful if a coding standard hard-codes progress or verbose output but you want PHPCS to be quiet -- Use the command "phpcs --config-set quiet true" to turn quiet mode on by default - Generic LineLength sniff no longer errors for comments that cannot be broken out onto a new line (request #766) -- A typical case is a comment that contains a very long URL -- The comment is ignored if putting the URL on a indented new comment line would be longer than the allowed length - Settings extensions in a ruleset no longer causes PHP notices during unit testing -- Thanks to Klaus Purer for the patch - Version control reports now show which errors are fixable if you are showing sources - Added a new sniff to enforce a single space after a NOT operator (request #1051) -- Include in a ruleset using the code Generic.Formatting.SpaceAfterNot - The Squiz.Commenting.BlockComment sniff now supports tabs for indenting comment lines (request #1056) - Fixed bug #790 : Incorrect missing @throws error in methods that use closures - Fixed bug #908 : PSR2 standard is not checking that closing brace is on line following the body - Fixed bug #945 : Incorrect indent behavior using deep-nested function and arrays - Fixed bug #961 : Two anonymous functions passed as function/method arguments cause indentation false positive - Fixed bug #1005 : Using global composer vendor autoload breaks PHP lowercase built-in function sniff -- Thanks to Michael Butler for the patch - Fixed bug #1007 : Squiz Unreachable code detection is not working properly with a closure inside a case - Fixed bug #1023 : PSR2.Classes.ClassDeclaration fails if class extends base class and "implements" is on trailing line - Fixed bug #1026 : Arrays in comma delimited class properties cause ScopeIndent to increase indent - Fixed bug #1028 : Squiz ArrayDeclaration incorrectly fixes multi-line array where end bracket is not on a new line - Fixed bug #1034 : Squiz FunctionDeclarationArgumentSpacing gives incorrect error when first arg is a variadic - Fixed bug #1036 : Adjacent assignments aligned analysis statement wrong - Fixed bug #1049 : Version control reports can show notices when the report width is very small - Fixed bug #21050 : PEAR MultiLineCondition sniff suppresses errors on last condition line 2.6.1 2.6.1 stable stable 2016-05-31 BSD License - The PHP-supplied T_COALESCE token has been replicated for PHP versions before 7.0 - Function return types of self, parent and callable are now tokenized as T_RETURN_TYPE -- Thanks to Jaroslav Hanslík for the patch - The default_standard config setting now allows multiple standards to be listed, like on the command line -- Thanks to Michael Mayer for the patch - Installations done via composer now only include the composer autoloader for PHP 5.3.2+ (request #942) - Added a rollbackChangeset() method to the Fixer class to purposely rollback the active changeset - Fixed bug #940 : Auto-fixing issue encountered with inconsistent use of braces - Fixed bug #943 : Squiz.PHP.InnerFunctions.NotAllowed reported in anonymous classes - Fixed bug #944 : PHP warning when running the latest phar - Fixed bug #951 : InlineIfDeclaration: invalid error produced with UTF-8 string - Fixed bug #957 : Operator spacing sniff errors when plus is used as part of a number -- Thanks to Klaus Purer for the patch - Fixed bug #959 : Call-time pass-by-reference false positive if there is a square bracket before the ampersand -- Thanks to Konstantin Leboev for the patch - Fixed bug #962 : Null coalescing operator (??) not detected as a token -- Thanks to Joel Posti for the patch - Fixed bug #973 : Anonymous class declaration and PSR1.Files.SideEffects.FoundWithSymbols - Fixed bug #974 : Error when file ends with "function" - Fixed bug #979 : Anonymous function with return type hint is not refactored as expected - Fixed bug #983 : Squiz.WhiteSpace.MemberVarSpacing.AfterComment fails to fix error when comment is not a docblock - Fixed bug #1010 : Squiz NonExecutableCode sniff does not detect boolean OR -- Thanks to Derek Henderson for the patch - Fixed bug #1015 : The Squiz.Commenting.FunctionComment sniff doesn't allow description in @return tag -- Thanks to Alexander Obuhovich for the patch - Fixed bug #1022 : Duplicate spaces after opening bracket error with PSR2 standard - Fixed bug #1025 : Syntax error in JS file can cause undefined index for parenthesis_closer 2.6.0 2.6.0 stable stable 2016-04-04 BSD License - Paths used when setting CLI arguments inside ruleset.xml files are now relative to the ruleset location (request #847) -- This change only applies to paths within ARG tags, used to set CLI arguments -- Previously, the paths were relative to the directory PHPCS was being run from -- Absolute paths are still allowed and work the same way they always have -- This change allows ruleset.xml files to be more portable - Content passed via STDIN will now be processed even if files are specified on the command line or in a ruleset - When passing content via STDIN, you can now specify the file path to use on the command line (request #934) -- This allows sniffs that check file paths to work correctly -- This is the same functionality provided by the phpcs_input_file line, except it is available on the command line - Files processed with custom tokenizers will no longer be skipped if they appear minified (request #877) -- If the custom tokenizer wants minified files skipped, it can set a $skipMinified member var to TRUE -- See the included JS and CSS tokenizers for an example - Config vars set in ruleset.xml files are now processed earlier, allowing them to be used during sniff registration -- Among other things, this allows the installed_paths config var to be set in ruleset.xml files -- Thanks to Pieter Frenssen for the patch - Improved detection of regular expressions in the JS tokenizer - Generic PHP Syntax sniff now uses PHP_BINARY (if available) to determine the path to PHP if no other path is available -- You can still manually set php_path to use a specific binary for testing -- Thanks to Andrew Berry for the patch - The PHP-supplied T_POW_EQUAL token has been replicated for PHP versions before 5.6 - Added support for PHP7 use group declarations (request #878) -- New tokens T_OPEN_USE_GROUP and T_CLOSE_USE_GROUP are assigned to the open and close curly braces - Generic ScopeIndent sniff now reports errors for every line that needs the indent changed (request #903) -- Previously, it ignored lines that were indented correctly in the context of their block -- This change produces more technically accurate error messages, but is much more verbose - The PSR2 and Squiz standards now allow multi-line default values in function declarations (request #542) -- Previously, these would automatically make the function a multi-line declaration - Squiz InlineCommentSniff now allows docblocks on require(_once) and include(_once) statements -- Thanks to Gary Jones for the patch - Squiz and PEAR Class and File sniffs no longer assume the first comment in a file is always a file comment -- phpDocumentor assigns the comment to the file only if it is not followed by a structural element -- These sniffs now follow this same rule - Squiz ClassCommentSniff no longer checks for blank lines before class comments -- Removes the error Squiz.Commenting.ClassComment.SpaceBefore - Renamed Squiz.CSS.Opacity.SpacingAfterPoint to Squiz.CSS.Opacity.DecimalPrecision -- Please update your ruleset if you are referencing this error code directly - Fixed PHP tokenizer problem that caused an infinite loop when checking a comment with specific content - Generic Disallow Space and Tab indent sniffs now detect and fix indents inside embedded HTML chunks (request #882) - Squiz CSS IndentationSniff no longer assumes the class opening brace is at the end of a line - Squiz FunctionCommentThrowTagSniff now ignores non-docblock comments - Squiz ComparisonOperatorUsageSniff now allows conditions like while(true) - PEAR FunctionCallSignatureSniff (and the Squiz and PSR2 sniffs that use it) now correctly check the first argument -- Further fix for bug #698 - Fixed bug #791 : codingStandardsChangeSetting settings not working with namespaces - Fixed bug #872 : Incorrect detection of blank lines between CSS class names - Fixed bug #879 : Generic InlineControlStructureSniff can create parse error when case/if/elseif/else have mixed brace and braceless definitions - Fixed bug #883 : PSR2 is not checking for blank lines at the start and end of control structures - Fixed bug #884 : Incorrect indentation notice for anonymous classes - Fixed bug #887 : Using curly braces for a shared CASE/DEFAULT statement can generate an error in PSR2 SwitchDeclaration - Fixed bug #889 : Closure inside catch/else/elseif causes indentation error - Fixed bug #890 : Function call inside returned short array value can cause indentation error inside CASE statements - Fixed bug #897 : Generic.Functions.CallTimePassByReference.NotAllowed false positive when short array syntax - Fixed bug #900 : Squiz.Functions.FunctionDeclarationArgumentSpacing bug when no space between type hint and argument - Fixed bug #902 : T_OR_EQUAL and T_POW_EQUAL are not seen as assignment tokens - Fixed bug #910 : Unrecognized "extends" and indentation on anonymous classes - Fixed bug #915 : JS Tokenizer generates errors when processing some decimals - Fixed bug #928 : Endless loop when sniffing a PHP file with a git merge conflict inside a function - Fixed bug #937 : Shebang can cause PSR1 SideEffects warning -- Thanks to Clay Loveless for the patch - Fixed bug #938 : CallTimePassByReferenceSniff ignores functions with return value 2.5.1 2.5.1 stable stable 2016-01-20 BSD License - The PHP-supplied T_SPACESHIP token has been replicated for PHP versions before 7.0 - T_SPACESHIP is now correctly identified as an operator -- Thanks to Alexander Obuhovich for the patch - Generic LowerCaseKeyword now ensures array type hints are lowercase as well -- Thanks to Mathieu Rochette for the patch - Squiz ComparisonOperatorUsageSniff no longer hangs on JS FOR loops that don't use semicolons - PHP_CodesSniffer now includes the composer autoload.php file, if there is one -- Thanks to Klaus Purer for the patch - Added error Squiz.Commenting.FunctionComment.ScalarTypeHintMissing for PHP7 only (request #858) -- These errors were previously reported as Squiz.Commenting.FunctionComment.TypeHintMissing on PHP7 -- Disable this error message in a ruleset.xml file if your code needs to run on both PHP5 and PHP7 - The PHP 5.6 __debugInfo magic method no longer produces naming convention errors -- Thanks to Michael Nowack for the patch - PEAR and Squiz FunctionComment sniffs now support variadic functions (request #841) - Fixed bug #622 : Wrong detection of Squiz.CSS.DuplicateStyleDefinition with media queries - Fixed bug #752 : The missing exception error is reported in first found DocBlock - Fixed bug #794 : PSR2 MultiLineFunctionDeclaration forbids comments after opening parenthesis of a multiline call - Fixed bug #820 : PEAR/PSR2 FunctionCallSignature sniffs suggest wrong indent when there are multiple arguments on a line - Fixed bug #822 : Ruleset hard-coded file paths are not used if not running from the same directory as the ruleset - Fixed bug #825 : FunctionCallArgumentSpacing sniff complains about more than one space before comment in multi-line function call - Fixed bug #828 : Null classname is tokenized as T_NULL instead of T_STRING - Fixed bug #829 : Short array argument not fixed correctly when multiple function arguments are on the same line - Fixed bug #831 : PHPCS freezes in an infinite loop under Windows if no standard is passed - Fixed bug #832 : Tokenizer does not support context sensitive parsing -- Thanks to Jaroslav Hanslík for the patch - Fixed bug #835 : PEAR.Functions.FunctionCallSignature broken when closure uses return types - Fixed bug #838 : CSS indentation fixer changes color codes -- Thanks to Klaus Purer for the patch - Fixed bug #839 : "__()" method is marked as not camel caps -- Thanks to Tim Bezhashvyly for the patch - Fixed bug #852 : Generic.Commenting.DocComment not finding errors when long description is omitted - Fixed bug #854 : Return typehints in interfaces are not reported as T_RETURN_TYPE -- Thanks to Jaroslav Hanslík for the patch - Fixed bug #855 : Capital letter detection for multibyte strings doesn't work correctly - Fixed bug #857 : PSR2.ControlStructure.SwitchDeclaration shouldn't check indent of curly brace closers - Fixed bug #859 : Switch statement indention issue when returning function call with closure - Fixed bug #861 : Single-line arrays and function calls can generate incorrect indentation errors - Fixed bug #867 : Squiz.Strings.DoubleQuoteUsage broken for some escape codes -- Thanks to Jack Blower for the help with the fix - Fixed bug #21005 : Incorrect indent detection when multiple properties are initialized to arrays - Fixed bug #21010 : Incorrect missing colon detection in CSS when first style is not on new line - Fixed bug #21011 : Incorrect error message text when newline found after opening brace 2.5.0 2.5.0 stable stable 2015-12-11 BSD License - PHPCS will now look for a phpcs.xml file in parent directories as well as the current directory (request #626) - PHPCS will now use a phpcs.xml file even if files are specified on the command line -- This file is still only used if no standard is specified on the command line - Added support for a phpcs.xml.dist file (request #583) -- If both a phpcs.xml and phpcs.xml.dist file are present, the phpcs.xml file will be used - Added support for setting PHP ini values in ruleset.xml files (request #560) -- Setting the value of the new ini tags to name="memory_limit" value="32M" is the same as -d memory_limit=32M - Added support for one or more bootstrap files to be run before processing begins -- Use the --bootstrap=file,file,file command line argument to include bootstrap files -- Useful if you want to override some of the high-level settings of PHPCS or PHPCBF -- Thanks to John Maguire for the patch - Added additional verbose output for CSS tokenizing - Squiz ComparisonOperatorUsageSniff now checks FOR, WHILE and DO-WHILE statements -- Thanks to Arnout Boks for the patch - Fixed bug #660 : Syntax checks can fail on Windows with PHP5.6 - Fixed bug #784 : $this->trait is seen as a T_TRAIT token - Fixed bug #786 : Switch indent issue with short array notation - Fixed bug #787 : SpacingAfterDefaultBreak confused by multi-line statements - Fixed bug #797 : Parsing CSS url() value breaks further parsing - Fixed bug #805 : Squiz.Commenting.FunctionComment.InvalidTypeHint on Scalar types on PHP7 - Fixed bug #807 : Cannot fix line endings when open PHP tag is not on the first line - Fixed bug #808 : JS tokeniser incorrectly setting some function and class names to control structure tokens - Fixed bug #809 : PHPCBF can break a require_once statement with a space before the open parenthesis - Fixed bug #813 : PEAR FunctionCallSignature checks wrong indent when first token on line is part of a multi-line string 2.4.0 2.4.0 stable stable 2015-11-24 BSD License - Added support for PHP 7 anonymous classes -- Anonymous classes are now tokenized as T_ANON_CLASS and ignored by normal class sniffs - Added support for PHP 7 function return type declarations -- Return types are now tokenized as T_RETURN_TYPE - Fixed tokenizing of the XOR operator, which was incorrectly identified as a power operator (bug #765) -- The T_POWER token has been removed and replaced by the T_BITWISE_XOR token -- The PHP-supplied T_POW token has been replicated for PHP versions before 5.6 - Traits are now tokenized in PHP versions before 5.4 to make testing easier - Improved regular expression detection in JS files - PEAR FunctionCallSignatureSniff now properly detects indents in more mixed HTML/PHP code blocks - Full report now properly indents lines when newlines are found inside error messages - Generating documentation without specifying a standard now uses the default standard instead -- Thanks to Ken Guest for the patch - Generic InlineControlStructureSniff now supports braceless do/while loops in JS -- Thanks to Pieter Frenssen for the patch - Added more guard code for function declarations with syntax errors -- Thanks to Yun Young-jin for the patch - Added more guard code for foreach declarations with syntax errors -- Thanks to Johan de Ruijter for the patch - Added more guard code for class declarations with syntax errors - Squiz ArrayDeclarationSniff now has guard code for arrays with syntax errors - Generic InlineControlStructureSniff now correctly fixes ELSEIF statements - Fixed bug #601 : Expected type hint int[]; found array in Squiz FunctionCommentSniff -- Thanks to Scato Eggen for the patch - Fixed bug #625 : Consider working around T_HASHBANG in HHVM 3.5.x and 3.6.x -- Thanks to Kunal Mehta for the patch - Fixed bug #692 : Comment tokenizer can break when using mbstring function overloading - Fixed bug #694 : Long sniff codes can cause PHP warnings in source report when showing error codes - Fixed bug #698 : PSR2.Methods.FunctionCallSignature.Indent forces exact indent of ternary operator parameters - Fixed bug #704 : ScopeIndent can fail when an opening parenthesis is on a line by itself - Fixed bug #707 : Squiz MethodScopeSniff doesn't handle nested functions - Fixed bug #709 : Squiz.Sniffs.Whitespace.ScopeClosingBraceSniff marking indented endif in mixed inline HTML blocks - Fixed bug #711 : Sniffing from STDIN shows Generic.Files.LowercasedFilename.NotFound error - Fixed bug #714 : Fixes suppression of errors using docblocks -- Thanks to Andrzej Karmazyn for the patch - Fixed bug #716 : JSON report is invalid when messages contain newlines or tabs -- Thanks to Pieter Frenssen for the patch - Fixed bug #723 : ScopeIndent can fail when multiple array closers are on the same line - Fixed bug #730 : ScopeIndent can fail when a short array opening square bracket is on a line by itself - Fixed bug #732 : PHP Notice if @package name is made up of all invalid characters -- Adds new error code PEAR.Commenting.FileComment.InvalidPackageValue - Fixed bug #748 : Auto fix for Squiz.Commenting.BlockComment.WrongEnd is incorrect -- Thanks to J.D. Grimes for the patch - Fixed bug #753 : PSR2 standard shouldn't require space after USE block when next code is a closing tag - Fixed bug #768 : PEAR FunctionCallSignature sniff forbids comments after opening parenthesis of a multiline call - Fixed bug #769 : Incorrect detection of variable reference operator when used with short array syntax -- Thanks to Klaus Purer for the patch - Fixed bug #772 : Syntax error when using PHPCBF on alternative style foreach loops - Fixed bug #773 : Syntax error when stripping trailing PHP close tag and previous statement has no semicolon - Fixed bug #778 : PHPCBF creates invalid PHP for inline FOREACH containing multiple control structures - Fixed bug #781 : Incorrect checking for PHP7 return types on multi-line function declarations - Fixed bug #782 : Conditional function declarations cause fixing conflicts in Squiz standard -- Squiz.ControlStructures.ControlSignature no longer enforces a single newline after open brace -- Squiz.WhiteSpace.ControlStructureSpacing can be used to check spacing at the start/end of control structures 2.3.4 2.3.4 stable stable 2015-09-09 BSD License - JSON report format now includes the fixable status for each error message and the total number of fixable errors - Added more guard code for function declarations with syntax errors - Added tokenizer support for the PHP declare construct -- Thanks to Andy Blyler for the patch - Generic UnnecessaryStringConcatSniff can now allow strings concatenated over multiple lines -- Set the allowMultiline property to TRUE (default is FALSE) in your ruleset.xml file to enable this -- By default, concat used only for getting around line length limits still generates an error -- Thanks to Stefan Lenselink for the contribution - Invalid byte sequences no longer throw iconv_strlen() errors (request #639) -- Thanks to Willem Stuursma for the patch - Generic TodoSniff and FixmeSniff are now better at processing strings with invalid characters - PEAR FunctionCallSignatureSniff now ignores indentation of inline HTML content - Squiz ControlSignatureSniff now supports control structures with only inline HTML content - Fixed bug #636 : Some class names cause CSS tokenizer to hang - Fixed bug #638 : VCS blame reports output error content from the blame commands for files not under VC - Fixed bug #642 : Method params incorrectly detected when default value uses short array syntax -- Thanks to Josh Davis for the patch - Fixed bug #644 : PEAR ScopeClosingBrace sniff does not work with mixed HTML/PHP - Fixed bug #645 : FunctionSignature and ScopeIndent sniffs don't detect indents correctly when PHP open tag is not on a line by itself - Fixed bug #648 : Namespace not tokenized correctly when followed by multiple use statements - Fixed bug #654 : Comments affect indent check for BSDAllman brace style - Fixed bug #658 : Squiz.Functions.FunctionDeclarationSpacing error for multi-line declarations with required spaces greater than zero -- Thanks to J.D. Grimes for the patch - Fixed bug #663 : No space after class name generates: Class name "" is not in camel caps format - Fixed bug #667 : Scope indent check can go into infinite loop due to some parse errors - Fixed bug #670 : Endless loop in PSR1 SideEffects sniffer if no semicolon after last statement -- Thanks to Thomas Jarosch for the patch - Fixed bug #672 : Call-time pass-by-reference false positive - Fixed bug #683 : Comments are incorrectly reported by PSR2.ControlStructures.SwitchDeclaration sniff - Fixed bug #687 : ScopeIndent does not check indent correctly for method prefixes like public and abstract - Fixed bug #689 : False error on some comments after class closing brace 2.3.3 2.3.3 stable stable 2015-06-24 BSD License - Improved the performance of the CSS tokenizer, especially on very large CSS files (thousands of lines) -- Thanks to Klaus Purer for the patch - Defined tokens for lower PHP versions are now phpcs-specific strings instead of ints -- Stops conflict with other projects, like PHP_CodeCoverage - Added more guard code for syntax errors to various sniffs - Improved support for older HHVM versions -- Thanks to Kunal Mehta for the patch - Squiz ValidLogicalOperatorsSniff now ignores XOR as type casting is different when using the ^ operator (request #567) - Squiz CommentedOutCodeSniff is now better at ignoring URLs inside comments - Squiz ControlSignatureSniff is now better at checking embedded PHP code - Squiz ScopeClosingBraceSniff is now better at checking embedded PHP code - Fixed bug #584 : Squiz.Arrays.ArrayDeclaration sniff gives incorrect NoComma error for multiline string values - Fixed bug #589 : PEAR.Functions.FunctionCallSignature sniff not checking all function calls - Fixed bug #592 : USE statement tokenising can sometimes result in mismatched scopes - Fixed bug #594 : Tokenizer issue on closure that returns by reference - Fixed bug #595 : Colons in CSS selectors within media queries throw false positives -- Thanks to Klaus Purer for the patch - Fixed bug #598 : PHPCBF can break function/use closure brace placement - Fixed bug #603 : Squiz ControlSignatureSniff hard-codes opener type while fixing - Fixed bug #605 : Auto report-width specified in ruleset.xml ignored - Fixed bug #611 : Invalid numeric literal on CSS files under PHP7 - Fixed bug #612 : Multi-file diff generating incorrectly if files do not end with EOL char - Fixed bug #615 : Squiz OperatorBracketSniff incorrectly reports and fixes operations using self:: - Fixed bug #616 : Squiz DisallowComparisonAssignmentSniff inconsistent errors with inline IF statements - Fixed bug #617 : Space after switch keyword in PSR-2 is not being enforced - Fixed bug #621 : PSR2 SwitchDeclaration sniff doesn't detect, or correctly fix, case body on same line as statement 2.3.2 2.3.2 stable stable 2015-04-29 BSD License - The error message for PSR2.ControlStructures.SwitchDeclaration.WrongOpenercase is now clearer (request #579) - Fixed bug #545 : Long list of CASE statements can cause tokenizer to reach a depth limit - Fixed bug #565 : Squiz.WhiteSpace.OperatorSpacing reports negative number in short array -- Thanks to Vašek Purchart for the patch -- Same fix also applied to Squiz.Formatting.OperatorBracket - Fixed bug #569 : Generic ScopeIndentSniff throws PHP notices in JS files - Fixed bug #570 : Phar class fatals in PHP less than 5.3 2.3.1 2.3.1 stable stable 2015-04-23 BSD License - PHPCS can now exit with 0 even if errors are found -- Set the ignore_errors_on_exit config variable to 1 to set this behaviour -- Use with the ignore_warnings_on_exit config variable to never return a non-zero exit code - Added Generic DisallowLongArraySyntaxSniff to enforce the use of the PHP short array syntax (request #483) -- Thanks to Xaver Loppenstedt for helping with tests - Added Generic DisallowShortArraySyntaxSniff to ban the use of the PHP short array syntax (request #483) -- Thanks to Xaver Loppenstedt for helping with tests - Generic ScopeIndentSniff no longer does exact checking for content inside parenthesis (request #528) -- Only applies to custom coding standards that set the "exact" flag to TRUE - Squiz ConcatenationSpacingSniff now has a setting to ignore newline characters around operators (request #511) -- Default remains FALSE, so newlines are not allowed -- Override the "ignoreNewlines" setting in a ruleset.xml file to change - Squiz InlineCommentSniff no longer checks the last char of a comment if the first char is not a letter (request #505) - The Squiz standard has increased the max padding for statement alignment from 12 to 20 - Fixed bug #479 : Yielded values are not recognised as returned values in Squiz FunctionComment sniff - Fixed bug #512 : Endless loop whilst parsing mixture of control structure styles - Fixed bug #515 : Spaces in JS block incorrectly flagged as indentation error - Fixed bug #523 : Generic ScopeIndent errors for IF in FINALLY - Fixed bug #527 : Closure inside IF statement is not tokenized correctly - Fixed bug #529 : Squiz.Strings.EchoedStrings gives false positive when echo'ing using an inline condition - Fixed bug #537 : Using --config-set is breaking phpcs.phar - Fixed bug #543 : SWITCH with closure in condition generates inline control structure error - Fixed bug #551 : Multiple catch blocks not checked in Squiz.ControlStructures.ControlSignature sniff - Fixed bug #554 : ScopeIndentSniff causes errors when encountering an unmatched parenthesis - Fixed bug #558 : PHPCBF adds brace for ELSE IF split over multiple lines - Fixed bug #564 : Generic MultipleStatementAlignment sniff reports incorrect errors for multiple assignments on a single line 2.3.0 2.3.0 stable stable 2015-03-04 BSD License - The existence of the main config file is now cached to reduce is_file() calls when it doesn't exist (request #486) - Abstract classes inside the Sniffs directory are now ignored even if they are named [Name]Sniff.php (request #476) -- Thanks to David Vernet for the patch - PEAR and Squiz FileComment sniffs no longer have @ in their error codes -- e.g., PEAR.Commenting.FileComment.Duplicate@categoryTag becomes PEAR.Commenting.FileComment.DuplicateCategoryTag -- e.g., Squiz.Commenting.FileComment.Missing@categoryTag becomes Squiz.Commenting.FileComment.MissingCategoryTag - PEAR MultiLineConditionSniff now allows comment lines inside multi-line IF statement conditions -- Thanks to Klaus Purer for the patch - Generic ForbiddenFunctionsSniff now supports setting null replacements in ruleset files (request #263) - Generic opening function brace sniffs now support checking of closures -- Set the checkClosures property to TRUE (default is FALSE) in your ruleset.xml file to enable this -- Can also set the checkFunctions property to FALSE (default is TRUE) in your ruleset.xml file to only check closures -- Affects OpeningFunctionBraceBsdAllmanSniff and OpeningFunctionBraceKernighanRitchieSniff - Generic OpeningFunctionBraceKernighanRitchieSniff can now fix all the errors it finds - Generic OpeningFunctionBraceKernighanRitchieSniff now allows empty functions with braces next to each other - Generic OpeningFunctionBraceBsdAllmanSniff now allows empty functions with braces next to each other - Improved auto report width for the "full" report - Improved conflict detection during auto fixing - Generic ScopeIndentSniff is no longer confused by empty closures - Squiz ControlSignatureSniff now always ignores comments (fixes bug #490) -- Include the Squiz.Commenting.PostStatementComment sniff in your ruleset.xml to ban these comments again - Squiz OperatorSpacingSniff no longer throws errors for code in the form ($foo || -1 === $bar) - Fixed errors tokenizing T_ELSEIF tokens on HHVM 3.5 - Squiz ArrayDeclarationSniff is no longer tricked by comments after array values - PEAR IncludingFileSniff no longer produces invalid code when removing parenthesis from require/include statements - Fixed bug #415 : The @codingStandardsIgnoreStart has no effect during fixing - Fixed bug #432 : Properties of custom sniffs cannot be configured - Fixed bug #453 : PSR2 standard does not allow closing tag for mixed PHP/HTML files - Fixed bug #457 : FunctionCallSignature sniffs do not support here/nowdoc syntax and can cause syntax error when fixing - Fixed bug #466 : PropertyLabelSpacing JS fixer issue when there is no space after colon - Fixed bug #473 : Writing a report for an empty folder to existing file includes the existing contents - Fixed bug #485 : PHP notice in Squiz.Commenting.FunctionComment when checking malformed @throws comment - Fixed bug #491 : Generic InlineControlStructureSniff can correct with missing semicolon -- Thanks to Jesse Donat for the patch - Fixed bug #492 : Use statements don't increase the scope indent - Fixed bug #493 : PSR1_Sniffs_Methods_CamelCapsMethodNameSniff false positives for some magic method detection -- Thanks to Andreas Möller for the patch - Fixed bug #496 : Closures in PSR2 are not checked for a space after the function keyword - Fixed bug #497 : Generic InlineControlStructureSniff does not support alternative SWITCH syntax - Fixed bug #500 : Functions not supported as values in Squiz ArrayDeclaration sniff - Fixed bug #501 : ScopeClosingBrace and ScopeIndent conflict with closures used as array values -- Generic ScopeIndentSniff may now report fewer errors for closures, but perform the same fixes - Fixed bug #502 : PSR1 SideEffectsSniff sees declare() statements as side effects 2.2.0 2.2.0 stable stable 2015-01-22 BSD License - Added (hopefully) tastefully used colors to report and progress output for the phpcs command -- Use the --colors command line argument to use colors in output -- Use the command "phpcs --config-set colors true" to turn colors on by default -- Use the --no-colors command line argument to turn colors off when the config value is set - Added support for using the full terminal width for report output -- Use the --report-width=auto command line argument to auto-size the reports -- Use the command "phpcs --config-set report_width auto" to use auto-sizing by default - Reports will now size to fit inside the report width setting instead of always using padding to fill the space - If no files or standards are specified, PHPCS will now look for a phpcs.xml file in the current directory -- This file has the same format as a standard ruleset.xml file -- The phpcs.xml file should specify (at least) files to process and a standard/sniffs to use -- Useful for running the phpcs and phpcbf commands without any arguments at the top of a repository - Default file paths can now be specified in a ruleset.xml file using the "file" tag -- File paths are only processed if no files were specified on the command line - Extensions specified on the CLI are now merged with those set in ruleset.xml files -- Previously, the ruleset.xml file setting replaced the CLI setting completely - Squiz coding standard now requires lowercase PHP constants (true, false and null) -- Removed Squiz.NamingConventions.ConstantCase sniff as the rule is now consistent across PHP and JS files - Squiz FunctionOpeningBraceSpaceSniff no longer does additional checks for JS functions -- PHP and JS functions and closures are now treated the same way - Squiz MultiLineFunctionDeclarationSniff now supports JS files - Interactive mode no longer breaks if you also specify a report type on the command line - PEAR InlineCommentSniff now fixes the Perl-style comments that it finds (request #375) - PSR2 standard no longer fixes the placement of docblock open tags as comments are excluded from this standard - PSR2 standard now sets a default tab width of 4 spaces - Generic DocCommentSniff now only disallows lowercase letters at the start of a long/short comment (request #377) -- All non-letter characters are now allowed, including markdown special characters and numbers - Generic DisallowMultipleStatementsSniff now allows multiple open/close tags on the same line (request #423) - Generic CharacterBeforePHPOpeningTagSniff now only checks the first PHP tag it finds (request #423) - Generic CharacterBeforePHPOpeningTagSniff now allows a shebang line at the start of the file (request #20481) - Generic InlineHTMLUnitTest now allows a shebang line at the start of the file (request #20481) - PEAR ObjectOperatorIndentSniff now only checks object operators at the start of a line - PEAR FileComment and ClassComment sniffs no longer have @ in their error codes -- E.g., PEAR.Commenting.FileComment.Missing@categoryTag becomes PEAR.Commenting.FileComment.MissingCategoryTag -- Thanks to Grzegorz Rygielski for the patch - Squiz ControlStructureSpacingSniff no longer enforces a blank line before CATCH statements - Squiz FunctionCommentSniff now fixes the return type in the @return tag (request #392) - Squiz BlockCommentSniff now only disallows lowercase letters at the start of the comment - Squiz InlineCommentSniff now only disallows lowercase letters at the start of the comment - Squiz OperatorSpacingSniff now has a setting to ignore newline characters around operators (request #348) -- Default remains FALSE, so newlines are not allowed -- Override the "ignoreNewlines" setting in a ruleset.xml file to change - PSR2 ControlStructureSpacingSniff now checks for, and fixes, newlines after the opening parenthesis - Added a markdown document generator (--generator=markdown to use) -- Thanks to Stefano Kowalke for the contribution - Fixed bug #379 : Squiz.Arrays.ArrayDeclaration.NoCommaAfterLast incorrectly detects comments - Fixed bug #382 : JS tokenizer incorrect for inline conditionally created immediately invoked anon function - Fixed bug #383 : Squiz.Arrays.ArrayDeclaration.ValueNoNewline incorrectly detects nested arrays - Fixed bug #386 : Undefined offset in Squiz.FunctionComment sniff when param has no comment - Fixed bug #390 : Indentation of non-control structures isn't adjusted when containing structure is fixed - Fixed bug #400 : InlineControlStructureSniff fails to fix when statement has no semicolon - Fixed bug #401 : PHPCBF no-patch option shows an error when there are no fixable violations in a file - Fixed bug #405 : The "Squiz.WhiteSpace.FunctionSpacing" sniff removes class "}" during fixing - Fixed bug #407 : PEAR.ControlStructures.MultiLineCondition doesn't account for comments at the end of lines - Fixed bug #410 : The "Squiz.WhiteSpace.MemberVarSpacing" not respecting "var" - Fixed bug #411 : Generic.WhiteSpace.ScopeIndent.Incorrect - false positive with multiple arrays in argument list - Fixed bug #412 : PSR2 multi-line detection doesn't work for inline IF and string concats - Fixed bug #414 : Squiz.WhiteSpace.MemberVarSpacing - inconsistent checking of member vars with comment - Fixed bug #433 : Wrong detection of Squiz.Arrays.ArrayDeclaration.KeyNotAligned when key contains space - Fixed bug #434 : False positive for spacing around "=>" in inline array within foreach - Fixed bug #452 : Ruleset exclude-pattern for specific sniff code ignored when using CLI --ignore option - Fixed bug #20482 : Scope indent sniff can get into infinite loop when processing a parse error 2.1.0 2.1.0 stable stable 2014-12-18 BSD License - Time and memory output is now shown if progress information is also shown (request #335) - A tilde can now be used to reference a user's home directory in a path to a standard (request #353) - Added PHP_CodeSniffer_File::findStartOfStatement() to find the first non-whitespace token in a statement -- Possible alternative for code using PHP_CodeSniffer_File::findPrevious() with the local flag set - Added PHP_CodeSniffer_File::findEndOfStatement() to find the last non-whitespace token in a statement -- Possible alternative for code using PHP_CodeSniffer_File::findNext() with the local flag set - Generic opening function brace sniffs now ensure the opening brace is the last content on the line -- Affects OpeningFunctionBraceBsdAllmanSniff and OpeningFunctionBraceKernighanRitchieSniff -- Also enforced in PEAR FunctionDeclarationSniff and Squiz MultiLineFunctionDeclarationSniff - Generic DisallowTabIndentSniff now replaces tabs everywhere it finds them, except in strings and here/now docs - Generic EmptyStatementSniff error codes now contain the type of empty statement detected (request #314) -- All messages generated by this sniff are now errors (empty CATCH was previously a warning) -- Message code Generic.CodeAnalysis.EmptyStatement.NotAllowed has been removed -- Message code Generic.CodeAnalysis.EmptyStatement.NotAllowedWarning has been removed -- New message codes have the format Generic.CodeAnalysis.EmptyStatement.Detected[TYPE] -- Example code is Generic.CodeAnalysis.EmptyStatement.DetectedCATCH -- You can now use a custom ruleset to change messages to warnings and to exclude them - PEAR and Squiz FunctionCommentSniffs no longer ban @return tags for constructors and destructors -- Removed message PEAR.Commenting.FunctionComment.ReturnNotRequired -- Removed message Squiz.Commenting.FunctionComment.ReturnNotRequired -- Change initiated by request #324 and request #369 - Squiz EmptyStatementSniff has been removed -- Squiz standard now includes Generic EmptyStatementSniff and turns off the empty CATCH error - Squiz ControlSignatureSniff fixes now retain comments between the closing parenthesis and open brace - Squiz SuperfluousWhitespaceSniff now checks for extra blank lines inside closures -- Thanks to Sertan Danis for the patch - Squiz ArrayDeclarationSniff now skips function calls while checking multi-line arrays - Fixed bug #337 : False positive with anonymous functions in Generic_Sniffs_WhiteSpace_ScopeIndentSniff - Fixed bug #339 : reformatting brace location can result in broken code - Fixed bug #342 : Nested ternary operators not tokenized correctly - Fixed bug #345 : Javascript regex not tokenized when inside array - Fixed bug #346 : PHP path can't be determined in some cases in "phpcs.bat" (on Windows XP) - Fixed bug #358 : False positives for Generic_Sniffs_WhiteSpace_ScopeIndentSniff - Fixed bug #361 : Sniff-specific exclude patterns don't work for Windows - Fixed bug #364 : Don't interpret "use function" as declaration - Fixed bug #366 : phpcbf with PSR2 errors on control structure alternative syntax - Fixed bug #367 : Nested Anonymous Functions Causing False Negative - Fixed bug #371 : Shorthand binary cast causes tokenizer errors -- New token T_BINARY_CAST added for the b"string" cast format (the 'b' is the T_BINARY_CAST token) - Fixed bug #372 : phpcbf parse problem, wrong brace placement for inline IF - Fixed bug #373 : Double quote usage fix removing too many double quotes - Fixed bug #20196 : 1.5.2 breaks scope_closer position 2.0.0 2.0.0 stable stable 2014-12-05 BSD License - JS tokenizer now sets functions as T_CLOSUREs if the function is anonymous - JS tokenizer now sets all objects to T_OBJECT -- Object end braces are set to a new token T_CLOSE_OBJECT -- T_OBJECT tokens no longer act like scopes; i.e., they have no condition/opener/closer -- T_PROPERTY tokens no longer act like scopes; i.e., they have no condition/opener/closer -- T_OBJECT tokens have a bracket_closer instead, which can be used to find the ending -- T_CLOSE_OBJECT tokens have a bracket_opener - Improved regular expression detection in the JS tokenizer - You can now get PHP_CodeSniffer to ignore a single line by putting @codingStandardsIgnoreLine in a comment -- When the comment is found, the comment line and the following line will be ignored -- Thanks to Andy Bulford for the contribution - PHPCBF now prints output when it is changing into directories - Improved conflict detection during auto fixing - The -vvv command line argument will now output the current file content for each loop during fixing - Generic ScopeIndentSniff now checks that open/close PHP tags are aligned to the correct column - PEAR FunctionCallSignatureSniff now checks indent of closing parenthesis even if it is not on a line by itself - PEAR FunctionCallSignatureSniff now supports JS files - PEAR MultiLineConditionSniff now supports JS files - Squiz DocCommentAlignmentSniff now supports JS files - Fixed a problem correcting the closing brace line in Squiz ArrayDeclarationSniff - Fixed a problem auto-fixing the Squiz.WhiteSpace.FunctionClosingBraceSpace.SpacingBeforeNestedClose error - Squiz EmbeddedPhpSniff no longer reports incorrect alignment of tags when they are not on new lines - Squiz EmbeddedPhpSniff now aligns open tags correctly when moving them onto a new line - Improved fixing of arrays with multiple values in Squiz ArrayDeclarationSniff - Improved detection of function comments in Squiz FunctionCommentSpacingSniff - Improved fixing of lines after cases statements in Squiz SwitchDeclarationSniff - Fixed bug #311 : Suppression of function prototype breaks checking of lines within function - Fixed bug #320 : Code sniffer indentation issue - Fixed bug #333 : Nested ternary operators causing problems 2.0.0RC4 2.0.0RC4 beta beta 2014-11-07 BSD License - JS tokenizer now detects xor statements correctly - Improved detection of properties and objects in the JS tokenizer - Generic ScopeIndentSniff can now fix indents using tabs instead of spaces -- Set the tabIndent property to TRUE in your ruleset.xml file to enable this -- It is important to also set a tab-width setting, either in the ruleset or on the command line, for accuracy - Generic ScopeIndentSniff now checks and auto-fixes JS files - Generic DisallowSpaceIndentSniff is now able to replace space indents with tab indents during fixing - Support for phpcs-only and phpcbf-only attributes has been added to all ruleset.xml elements -- Allows parts of the ruleset to only apply when using a specific tool -- Useful for doing things like excluding indent fixes but still reporting indent errors - Unit tests can now set command line arguments during a test run -- Override getCliValues() and pass an array of CLI arguments for each file being tested - File-wide sniff properties can now be set using T_INLINE_HTML content during unit test runs -- Sniffs that start checking at the open tag can only, normally, have properties set using a ruleset - Generic ConstructorNameSniff no longer errors for PHP4 style constructors when __construct() is present -- Thanks to Thibaud Fabre for the patch - Generic DocCommentSniff now checks that the end comment tag is on a new line - Generic MultipleStatementAlignmentSniff no longer skips assignments for closures - Squiz DocCommentAlignment sniff now has better checking for single line doc block - Running unit tests with the -v CLI argument no longer generates PHP errors - Fixed bug #295 : ScopeIndentSniff hangs when processing nested closures - Fixed bug #298 : False positive in ScopeIndentSniff when anonymous functions are used with method chaining - Fixed bug #302 : Fixing code in Squiz InlineComment sniff can remove some comment text - Fixed bug #303 : Open and close tag on same line can cause a PHP notice checking scope indent - Fixed bug #306 : File containing only a namespace declaration raises undefined index notice - Fixed bug #307 : Conditional breaks in case statements get incorrect indentations - Fixed bug #308 : Squiz InlineIfDeclarationSniff fails on ternary operators inside closure - Fixed bug #310 : Variadics not recognized by tokenizer 2.0.0RC3 2.0.0RC3 beta beta 2014-10-16 BSD License - Improved default output for PHPCBF and removed the options to print verbose and progress output - If a .fixed file is supplied for a unit test file, the auto fixes will be checked against it during testing -- See Generic ScopeIndentUnitTest.inc and ScopeIndentUnitTest.inc.fixed for an example - Fixer token replacement methods now return TRUE if the change was accepted and FALSE if rejected - The --config-show command now pretty-prints the config values -- Thanks to Ken Guest for the patch - Setting and removing config values now catches exceptions if the config file is not writable -- Thanks to Ken Guest for the patch - Setting and removing config values now prints a message to confirm the action and show old values - Generic ScopeIndentSniff has been completely rewritten to improve fixing and embedded PHP detection - Generic DisallowTabIndent and DisallowSpaceIndent sniffs now detect indents at the start of block comments - Generic DisallowTabIndent and DisallowSpaceIndent sniffs now detect indents inside multi-line strings - Generic DisallowTabIndentSniff now replaces tabs inside doc block comments - Squiz ControlStructureSpacingSniff error codes have been corrected; they were reversed - Squiz EmbeddedPhpSniff now checks open and close tag indents and fixes some errors - Squiz FileCommentSniff no longer throws incorrect blank line before comment errors in JS files - Squiz ClassDeclarationSniff now has better checking for blank lines after a closing brace - Removed error Squiz.Classes.ClassDeclaration.NoNewlineAfterCloseBrace (request #285) -- Already handled by Squiz.Classes.ClassDeclaration.CloseBraceSameLine - Fixed bug #280 : The --config-show option generates error when there is no config file 2.0.0RC2 2.0.0RC2 beta beta 2014-09-26 BSD License - Minified JS and CSS files are now detected and skipped (fixes bug #252 and bug #19899) -- A warning will be added to the file so it can be found in the report and ignored in the future - Fixed incorrect length of JS object operator tokens - PHP tokenizer no longer converts class/function names to special tokens types -- Class/function names such as parent and true would become special tokens such as T_PARENT and T_TRUE - PHPCS can now exit with 0 if only warnings were found (request #262) -- Set the ignore_warnings_on_exit config variable to 1 to set this behaviour -- Default remains at exiting with 0 only if no errors and no warnings were found -- Also changes return value of PHP_CodeSniffer_Reporting::printReport() - Rulesets can now set associative array properties -- property name="[property]" type="array" value="foo=>bar,baz=>qux" - Generic ForbiddenFunctionsSniff now has a public property called forbiddenFunctions (request #263) -- Override the property in a ruleset.xml file to define forbidden functions and their replacements -- A replacement of NULL indicates that no replacement is available -- e.g., value="delete=>unset,print=>echo,create_function=>null" -- Custom sniffs overriding this one will need to change the visibility of their member var - Improved closure support in Generic ScopeIndentSniff - Improved indented PHP tag support in Generic ScopeIndentSniff - Improved fixing of mixed line indents in Generic ScopeIndentSniff - Added conflict detection to the file fixer -- If 2 sniffs look to be conflicting, one change will be ignored to allow a fix to occur - Generic CamelCapsFunctionNameSniff now ignores a single leading underscore -- Thanks to Alex Slobodiskiy for the patch - Standards can now be located within hidden directories (further fix for bug #20323) -- Thanks to Klaus Purer for the patch - Sniff ignore patterns now replace Win dir separators like file ignore patterns already did - Exclude patterns now use backtick delimiters, allowing all special characters to work correctly again -- Thanks to Jeremy Edgell for the patch - Errors converted to warnings in a ruleset (and vice versa) now retain their fixable status -- Thanks to Alexander Obuhovich for the patch - Squiz ConcatenationSpacingSniff now has a setting to specify how many spaces there should around concat operators -- Default remains at 0 -- Override the "spacing" setting in a ruleset.xml file to change - Added auto-fixes for Squiz InlineCommentSniff - Generic DocCommentSniff now correctly fixes additional blank lines at the end of a comment - Squiz OperatorBracketSniff now correctly fixes operations that include arrays - Zend ClosingTagSniff fix now correctly leaves closing tags when followed by HTML - Added Generic SyntaxSniff to check for syntax errors in PHP files -- Thanks to Blaine Schmeisser for the contribution - Added Generic OneTraitPerFileSniff to check that only one trait is defined in each file -- Thanks to Alexander Obuhovich for the contribution - Squiz DiscouragedFunctionsSniff now warns about var_dump() - PEAR ValidFunctionNameSniff no longer throws an error for _() - Squiz and PEAR FunctionCommentSniffs now support _() - Generic DisallowTabIndentSniff now checks for, and fixes, mixed indents again - Generic UpperCaseConstantSniff and LowerCaseConstantSniff now ignore function names - Fixed bug #243 : Missing DocBlock not detected - Fixed bug #248 : FunctionCommentSniff expects ampersand on param name - Fixed bug #265 : False positives with type hints in ForbiddenFunctionsSniff - Fixed bug #20373 : Inline comment sniff tab handling way - Fixed bug #20377 : Error when trying to execute phpcs with report=json - Fixed bug #20378 : Report appended to existing file if no errors found in run - Fixed bug #20381 : Invalid "Comment closer must be on a new line" -- Thanks to Brad Kent for the patch - Fixed bug #20402 : SVN pre-commit hook fails due to unknown argument error 2.0.0RC1 2.0.0RC1 beta beta 2014-08-06 BSD License - PHPCBF will now fix incorrect newline characters in a file - PHPCBF now exists cleanly when there are no errors to fix - Added phpcbf.bat file for Windows - Verbose option no longer errors when using a phar file with a space in the path - Fixed a reporting error when using HHVM -- Thanks to Martins Sipenko for the patch - addFixableError() and addFixableWarning() now only return true if the fixer is enabled -- Saves checking ($phpcsFile->fixer->enabled === true) before every fix - Added addErrorOnLine() and addWarningOnLine() to add a non-fixable violation to a line at column 1 -- Useful if you are generating errors using an external tool or parser and only know line numbers -- Thanks to Ondřej Mirtes for the patch - CSS tokenizer now identifies embedded PHP code using the new T_EMBEDDED_PHP token type -- The entire string of PHP is contained in a single token - PHP tokenizer contains better detection of short array syntax - Unit test runner now also test any standards installed under the installed_paths config var - Exclude patterns now use {} delimiters, allowing the | special character to work correctly again - The filtering component of the --extensions argument is now ignored again when passing filenames -- Can still be used to specify a custom tokenizer for each extension when passing filenames -- If no tokenizer is specified, default values will be used for common file extensions - Diff report now produces relative paths on Windows, where possible (further fix for bug #20234) - If a token's content has been modified by the tab-width setting, it will now have an orig_content in the tokens array - Generic DisallowSpaceIndent and DisallowTabIndent sniffs now check original indent content even when tab-width is set -- Previously, setting --tab-width would force both to check the indent as spaces - Fixed a problem where PHPCBF could replace tabs with too many spaces when changing indents - Fixed a problem that could occur with line numbers when using HHVM to check files with Windows newline characters - Removed use of sys_get_temp_dir() as this is not supported by the min PHP version - Squiz ArrayDeclarationSniff now supports short array syntax - Squiz ControlSignatureSniff no longer uses the Abstract Pattern sniff -- If you are extending this sniff, you'll need to rewrite your code -- The rewrite allows this sniff to fix all control structure formatting issues it finds - The installed_paths config var now accepts relative paths -- The paths are relative to the PHP_CodeSniffer install directory -- Thanks to Weston Ruter for the patch - Generic ScopeIndentSniff now accounts for different open tag indents - PEAR FunctionDeclarationSniff now ignores short arrays when checking indent -- Thanks to Daniel Tschinder for the patch - PSR2 FunctionCallSignatureSniff now treats multi-line strings as a single-line argument, like arrays and closures -- Thanks to Dawid Nowak for the patch - PSR2 UseDeclarationSniff now checks for a single space after the USE keyword - Generic ForbiddenFunctionsSniff now detects calls to functions in the global namespace -- Thanks to Ole Martin Handeland for the patch - Generic LowerCaseConstantSniff and UpperCaseConstantSniff now ignore namespaces beginning with TRUE/FALSE/NULL -- Thanks to Renan Gonçalves for the patch - Squiz InlineCommentSniff no longer requires a blank line after post-statement comments (request #20299) - Squiz SelfMemberReferenceSniff now works correctly with namespaces - Squiz FunctionCommentSniff is now more relaxed when checking namespaced type hints - Tab characters are now encoded in abstract pattern errors messages -- Thanks to Blaine Schmeisser for the patch - Invalid sniff codes passed to --sniffs now show a friendly error message (request #20313) - Generic LineLengthSniff now shows a warning if the iconv module is disabled (request #20314) - Source report no longer shows errors if category or sniff names ends in an uppercase error -- Thanks to Jonathan Marcil for the patch - Fixed bug #20261 : phpcbf has an endless fixing loop - Fixed bug #20268 : Incorrect documentation titles in PEAR documentation - Fixed bug #20296 : new array notion in function comma check fails - Fixed bug #20297 : phar does not work when renamed it to phpcs - Fixed bug #20307 : PHP_CodeSniffer_Standards_AbstractVariableSniff analyze traits - Fixed bug #20308 : Squiz.ValidVariableNameSniff - wrong variable usage - Fixed bug #20309 : Use "member variable" term in sniff "processMemberVar" method - Fixed bug #20310 : PSR2 does not check for space after function name - Fixed bug #20322 : Display rules set to type=error even when suppressing warnings - Fixed bug #20323 : PHPCS tries to load sniffs from hidden directories - Fixed bug #20346 : Fixer endless loop with Squiz.CSS sniffs - Fixed bug #20355 : No sniffs are registered with PHAR on Windows 2.0.0a2 2.0.0a2 alpha alpha 2014-05-01 BSD License - Added report type --report=info to show information about the checked code to make building a standard easier -- Checks a number of things, such as what line length you use, and spacing are brackets, but not everything -- Still highly experimental - Generic LineLengthSniff now shows warnings for long lines referring to licence and VCS information -- It previously ignored these lines, but at the expense of performance - Generic DisallowTabIndent and DisallowSpaceIndent sniffs no longer error when detecting mixed indent types -- Only the first type of indent found on a line (space or indent) is considered - Lots of little performance improvements that can add up to a substantial saving over large code bases -- Added a "length" array index to tokens so you don't need to call strlen() of them, or deal with encoding -- Can now use isset() to find tokens inside the PHP_CodeSniffer_Tokens static vars instead of in_array() - Custom reports can now specify a $recordErrors member var; this previously only worked for built-in reports -- When set to FALSE, error messages will not be recorded and only totals will be returned -- This can save significant memory while processing a large code base - Removed dependence on PHP_Timer - PHP tokenizer now supports DEFAULT statements opened with a T_SEMICOLON - The Squiz and PHPCS standards have increased the max padding for statement alignment from 8 to 12 - Squiz EchoedStringsSniff now supports statements without a semicolon, such as PHP embedded in HTML - Squiz DoubleQuoteUsageSniff now properly replaces escaped double quotes when fixing a doubled quoted string - Improved detection of nested IF statements that use the alternate IF/ENDIF syntax - PSR1 CamelCapsMethodNameSniff now ignores magic methods -- Thanks to Eser Ozvataf for the patch - PSR1 SideEffectsSniff now ignores methods named define() - PSR1 and PEAR ClassDeclarationSniffs now support traits (request #20208) - PSR2 ControlStructureSpacingSniff now allows newlines before/after parentheses -- Thanks to Maurus Cuelenaere for the patch - PSR2 ControlStructureSpacingSniff now checks TRY and CATCH statements - Squiz SuperfluousWhitespaceSniff now detects whitespace at the end of block comment lines -- Thanks to Klaus Purer for the patch - Squiz LowercasePHPFunctionsSniff no longer reports errors for namespaced functions -- Thanks to Max Galbusera for the patch - Squiz SwitchDeclarationSniff now allows exit() as a breaking statement for case/default - Squiz ValidVariableNameSniff and Zend ValidVariableNameSniff now ignore additional PHP reserved vars -- Thanks to Mikuláš Dítě and Adrian Crepaz for the patch - Sniff code Squiz.WhiteSpace.MemberVarSpacing.After changed to Squiz.WhiteSpace.MemberVarSpacing.Incorrect (request #20241) - Fixed bug #20200 : Invalid JSON produced with specific error message - Fixed bug #20204 : Ruleset exclude checks are case sensitive - Fixed bug #20213 : Invalid error, Inline IF must be declared on single line - Fixed bug #20225 : array_merge() that takes more than one line generates error - Fixed bug #20230 : Squiz ControlStructureSpacing sniff assumes specific condition formatting - Fixed bug #20234 : phpcbf patch command absolute paths - Fixed bug #20240 : Squiz block comment sniff fails when newline present - Fixed bug #20247 : The Squiz.WhiteSpace.ControlStructureSpacing sniff and do-while -- Thanks to Alexander Obuhovich for the patch - Fixed bug #20248 : The Squiz_Sniffs_WhiteSpace_ControlStructureSpacingSniff sniff and empty scope - Fixed bug #20252 : Unitialized string offset when package name starts with underscore 2.0.0a1 2.0.0a1 alpha alpha 2014-02-05 BSD License - Added the phpcbf script to automatically fix many errors found by the phpcs script - Added report type --report=diff to show suggested changes to fix coding standard violations - The --report argument now allows for custom reports to be used -- Use the full path to your custom report class as the report name - The --extensions argument is now respected when passing filenames; not just with directories - The --extensions argument now allows you to specify the tokenizer for each extension -- e.g., --extensions=module/php,es/js - Command line arguments can now be set in ruleset files -- e.g., arg name="report" value="summary" (print summary report; same as --report=summary) -- e.g., arg value="sp" (print source and progress information; same as -sp) -- The -vvv, --sniffs, --standard and -l command line arguments cannot be set in this way - Sniff process() methods can not optionally return a token to ignore up to -- If returned, the sniff will not be executed again until the passed token is reached in the file -- Useful if you are looking for tokens like T_OPEN_TAG but only want to process the first one - Removed the comment parser classes and replaced it with a simple comment tokenizer -- T_DOC_COMMENT tokens are now tokenized into T_DOC_COMMENT_* tokens so they can be used more easily -- This change requires a significant rewrite of sniffs that use the comment parser -- This change requires minor changes to sniffs that listen for T_DOC_COMMENT tokens directly - Added Generic DocCommentSniff to check generic doc block formatting -- Removed doc block formatting checks from PEAR ClassCommentSniff -- Removed doc block formatting checks from PEAR FileCommentSniff -- Removed doc block formatting checks from PEAR FunctionCommentSniff -- Removed doc block formatting checks from Squiz ClassCommentSniff -- Removed doc block formatting checks from Squiz FileCommentSniff -- Removed doc block formatting checks from Squiz FunctionCommentSniff -- Removed doc block formatting checks from Squiz VariableCommentSniff - Squiz DocCommentAlignmentSniff has had its error codes changed -- NoSpaceBeforeTag becomes NoSpaceAfterStar -- SpaceBeforeTag becomes SpaceAfterStar -- SpaceBeforeAsterisk becomes SpaceBeforeStar - Generic MultipleStatementAlignment now aligns assignments within a block so they fit within their max padding setting -- The sniff previously requested the padding as 1 space if max padding was exceeded -- It now aligns the assignment with surrounding assignments if it can -- Removed property ignoreMultiline as multi-line assignments are now handled correctly and should not be ignored - Squiz FunctionClosingBraceSpaceSniff now requires a blank line before the brace in all cases except function args - Added error Squiz.Commenting.ClassComment.SpacingAfter to ensure there are no blank lines after a class comment - Added error Squiz.WhiteSpace.MemberVarSpacing.AfterComment to ensure there are no blank lines after a member var comment -- Fixes have also been corrected to not strip the member var comment or indent under some circumstances -- Thanks to Mark Scherer for help with this fix - Added error Squiz.Commenting.FunctionCommentThrowTag.Missing to ensure a throw is documented - Removed error Squiz.Commenting.FunctionCommentThrowTag.WrongType - Content passed via STDIN can now specify the filename to use so that sniffs can run the correct filename checks -- Ensure the first line of the content is: phpcs_input_file: /path/to/file - Squiz coding standard now enforces no closing PHP tag at the end of a pure PHP file - Squiz coding standard now enforces a single newline character at the end of the file - Squiz ClassDeclarationSniff no longer checks for a PHP ending tag after a class definition - Squiz ControlStructureSpacingSniff now checks TRY and CATCH statements as well - Removed MySource ChannelExceptionSniff 1.5.6 1.5.6 stable stable 2014-12-05 BSD License - JS tokenizer now detects xor statements correctly - The --config-show command now pretty-prints the config values -- Thanks to Ken Guest for the patch - Setting and removing config values now catches exceptions if the config file is not writable -- Thanks to Ken Guest for the patch - Setting and removing config values now prints a message to confirm the action and show old values - You can now get PHP_CodeSniffer to ignore a single line by putting @codingStandardsIgnoreLine in a comment -- When the comment is found, the comment line and the following line will be ignored -- Thanks to Andy Bulford for the contribution - Generic ConstructorNameSniff no longer errors for PHP4 style constructors when __construct() is present -- Thanks to Thibaud Fabre for the patch - Fixed bug #280 : The --config-show option generates error when there is no config file - Fixed bug #306 : File containing only a namespace declaration raises undefined index notice - Fixed bug #308 : Squiz InlineIfDeclarationSniff fails on ternary operators inside closure - Fixed bug #310 : Variadics not recognized by tokenizer - Fixed bug #311 : Suppression of function prototype breaks checking of lines within function 1.5.5 1.5.5 stable stable 2014-09-25 BSD License - PHP tokenizer no longer converts class/function names to special tokens types -- Class/function names such as parent and true would become special tokens such as T_PARENT and T_TRUE - Improved closure support in Generic ScopeIndentSniff - Improved indented PHP tag support in Generic ScopeIndentSniff - Generic CamelCapsFunctionNameSniff now ignores a single leading underscore -- Thanks to Alex Slobodiskiy for the patch - Standards can now be located within hidden directories (further fix for bug #20323) -- Thanks to Klaus Purer for the patch - Added Generic SyntaxSniff to check for syntax errors in PHP files -- Thanks to Blaine Schmeisser for the contribution - Squiz DiscouragedFunctionsSniff now warns about var_dump() - PEAR ValidFunctionNameSniff no longer throws an error for _() - Squiz and PEAR FunctionCommentSnif now support _() - Generic UpperCaseConstantSniff and LowerCaseConstantSniff now ignore function names - Fixed bug #248 : FunctionCommentSniff expects ampersand on param name - Fixed bug #265 : False positives with type hints in ForbiddenFunctionsSniff - Fixed bug #20373 : Inline comment sniff tab handling way - Fixed bug #20378 : Report appended to existing file if no errors found in run - Fixed bug #20381 : Invalid "Comment closer must be on a new line" -- Thanks to Brad Kent for the patch - Fixed bug #20386 : Squiz.Commenting.ClassComment.SpacingBefore thrown if first block comment 1.5.4 1.5.4 stable stable 2014-08-06 BSD License - Removed use of sys_get_temp_dir() as this is not supported by the min PHP version - The installed_paths config var now accepts relative paths -- The paths are relative to the PHP_CodeSniffer install directory -- Thanks to Weston Ruter for the patch - Generic ScopeIndentSniff now accounts for different open tag indents - PEAR FunctionDeclarationSniff now ignores short arrays when checking indent -- Thanks to Daniel Tschinder for the patch - PSR2 FunctionCallSignatureSniff now treats multi-line strings as a single-line argument, like arrays and closures -- Thanks to Dawid Nowak for the patch - Generic ForbiddenFunctionsSniff now detects calls to functions in the global namespace -- Thanks to Ole Martin Handeland for the patch - Generic LowerCaseConstantSniff and UpperCaseConstantSniff now ignore namespaces beginning with TRUE/FALSE/NULL -- Thanks to Renan Gonçalves for the patch - Squiz InlineCommentSniff no longer requires a blank line after post-statement comments (request #20299) - Squiz SelfMemberReferenceSniff now works correctly with namespaces - Tab characters are now encoded in abstract pattern errors messages -- Thanks to Blaine Schmeisser for the patch - Invalid sniff codes passed to --sniffs now show a friendly error message (request #20313) - Generic LineLengthSniff now shows a warning if the iconv module is disabled (request #20314) - Source report no longer shows errors if category or sniff names ends in an uppercase error -- Thanks to Jonathan Marcil for the patch - Fixed bug #20268 : Incorrect documentation titles in PEAR documentation - Fixed bug #20296 : new array notion in function comma check fails - Fixed bug #20307 : PHP_CodeSniffer_Standards_AbstractVariableSniff analyze traits - Fixed bug #20308 : Squiz.ValidVariableNameSniff - wrong variable usage - Fixed bug #20309 : Use "member variable" term in sniff "processMemberVar" method - Fixed bug #20310 : PSR2 does not check for space after function name - Fixed bug #20322 : Display rules set to type=error even when suppressing warnings - Fixed bug #20323 : PHPCS tries to load sniffs from hidden directories 1.5.3 1.5.3 stable stable 2014-05-01 BSD License - Improved detection of nested IF statements that use the alternate IF/ENDIF syntax - PHP tokenizer now supports DEFAULT statements opened with a T_SEMICOLON - PSR1 CamelCapsMethodNameSniff now ignores magic methods -- Thanks to Eser Ozvataf for the patch - PSR1 SideEffectsSniff now ignores methods named define() - PSR1 and PEAR ClassDeclarationSniffs now support traits (request #20208) - PSR2 ControlStructureSpacingSniff now allows newlines before/after parentheses -- Thanks to Maurus Cuelenaere for the patch - Squiz LowercasePHPFunctionsSniff no longer reports errors for namespaced functions -- Thanks to Max Galbusera for the patch - Squiz SwitchDeclarationSniff now allows exit() as a breaking statement for case/default - Squiz ValidVariableNameSniff and Zend ValidVariableNameSniff now ignore additional PHP reserved vars -- Thanks to Mikuláš Dítě and Adrian Crepaz for the patch - Sniff code Squiz.WhiteSpace.MemberVarSpacing.After changed to Squiz.WhiteSpace.MemberVarSpacing.Incorrect (request #20241) - Fixed bug #20200 : Invalid JSON produced with specific error message - Fixed bug #20204 : Ruleset exclude checks are case sensitive - Fixed bug #20213 : Invalid error, Inline IF must be declared on single line - Fixed bug #20225 : array_merge() that takes more than one line generates error - Fixed bug #20230 : Squiz ControlStructureSpacing sniff assumes specific condition formatting - Fixed bug #20240 : Squiz block comment sniff fails when newline present - Fixed bug #20247 : The Squiz.WhiteSpace.ControlStructureSpacing sniff and do-while -- Thanks to Alexander Obuhovich for the patch - Fixed bug #20248 : The Squiz_Sniffs_WhiteSpace_ControlStructureSpacingSniff sniff and empty scope - Fixed bug #20252 : Uninitialized string offset when package name starts with underscore 1.5.2 1.5.2 stable stable 2014-02-05 BSD License - Improved support for the PHP 5.5. classname::class syntax -- PSR2 SwitchDeclarationSniff no longer throws errors when this syntax is used in CASE conditions - Improved support for negative checks of instanceOf in Squiz ComparisonOperatorUsageSniff -- Thanks to Martin Winkel for the patch - Generic FunctionCallArgumentSpacingSniff now longer complains about space before comma when using here/nowdocs -- Thanks to Richard van Velzen for the patch - Generic LowerCaseConstantSniff and UpperCaseConstantSniff now ignore class constants -- Thanks to Kristopher Wilson for the patch - PEAR FunctionCallSignatureSniff now has settings to specify how many spaces should appear before/after parentheses -- Override the 'requiredSpacesAfterOpen' and 'requiredSpacesBeforeClose' settings in a ruleset.xml file to change -- Default remains at 0 for both -- Thanks to Astinus Eberhard for the patch - PSR2 ControlStructureSpacingSniff now has settings to specify how many spaces should appear before/after parentheses -- Override the 'requiredSpacesAfterOpen' and 'requiredSpacesBeforeClose' settings in a ruleset.xml file to change -- Default remains at 0 for both -- Thanks to Astinus Eberhard for the patch - Squiz ForEachLoopDeclarationSniff now has settings to specify how many spaces should appear before/after parentheses -- Override the 'requiredSpacesAfterOpen' and 'requiredSpacesBeforeClose' settings in a ruleset.xml file to change -- Default remains at 0 for both -- Thanks to Astinus Eberhard for the patch - Squiz ForLoopDeclarationSniff now has settings to specify how many spaces should appear before/after parentheses -- Override the 'requiredSpacesAfterOpen' and 'requiredSpacesBeforeClose' settings in a ruleset.xml file to change -- Default remains at 0 for both -- Thanks to Astinus Eberhard for the patch - Squiz FunctionDeclarationArgumentSpacingSniff now has settings to specify how many spaces should appear before/after parentheses -- Override the 'requiredSpacesAfterOpen' and 'requiredSpacesBeforeClose' settings in a ruleset.xml file to change -- Default remains at 0 for both -- Thanks to Astinus Eberhard for the patch - Removed UnusedFunctionParameter, CyclomaticComplexity and NestingLevel from the Squiz standard - Generic FixmeSniff and TodoSniff now work correctly with accented characters - Fixed bug #20145 : Custom ruleset preferences directory over installed standard - Fixed bug #20147 : phpcs-svn-pre-commit - no more default error report - Fixed bug #20151 : Problem handling "if(): ... else: ... endif;" syntax - Fixed bug #20190 : Invalid regex in Squiz_Sniffs_WhiteSpace_SuperfluousWhitespaceSniff 1.5.1 1.5.1 stable stable 2013-12-12 BSD License - Config values can now be set at runtime using the command line argument [--runtime-set key value] -- Runtime values are the same as config values, but are not written to the main config file -- Thanks to Wim Godden for the patch - Config values can now be set in ruleset files -- e.g., config name="zend_ca_path" value="/path/to/ZendCodeAnalyzer" -- Can not be used to set config values that override command line values, such as show_warnings -- Thanks to Jonathan Marcil for helping with the patch - Added a new installed_paths config value to allow for the setting of directories that contain standards -- By default, standards have to be installed into the CodeSniffer/Standards directory to be considered installed -- New config value allows a list of paths to be set in addition to this internal path -- Installed standards appear when using the -i arg, and can be referenced in rulesets using only their name -- Set paths by running: phpcs --config-set installed_paths /path/one,/path/two,... - PSR2 ClassDeclarationSniff now allows a list of extended interfaces to be split across multiple lines - Squiz DoubleQuoteUsageSniff now allows \b in double quoted strings - Generic ForbiddenFunctionsSniff now ignores object creation -- This is a further fix for bug #20100 : incorrect Function mysql() has been deprecated report - Fixed bug #20136 : Squiz_Sniffs_WhiteSpace_ScopeKeywordSpacingSniff and Traits - Fixed bug #20138 : Protected property underscore and camel caps issue (in trait with Zend) -- Thanks to Gaetan Rousseau for the patch - Fixed bug #20139 : No report file generated on success 1.5.0 1.5.0 stable stable 2013-11-28 BSD License - Doc generation is now working again for installed standards -- Includes a fix for limiting the docs to specific sniffs - Generic ScopeIndentSniff now allows for ignored tokens to be set via ruleset.xml files -- E.g., to ignore comments, override a property using: -- name="ignoreIndentationTokens" type="array" value="T_COMMENT,T_DOC_COMMENT" - PSR2 standard now ignores comments when checking indentation rules - Generic UpperCaseConstantNameSniff no longer reports errors where constants are used (request #20090) -- It still reports errors where constants are defined - Individual messages can now be excluded in ruleset.xml files using the exclude tag (request #20091) -- Setting message severity to 0 continues to be supported - Squiz OperatorSpacingSniff no longer throws errors for the ?: short ternary operator -- Thanks to Antoine Musso for the patch - Comment parser now supports non-English characters when splitting comment lines into words -- Thanks to Nik Sun for the patch - Exit statements are now recognised as valid closers for CASE and DEFAULT blocks -- Thanks to Maksim Kochkin for the patch - PHP_CodeSniffer_CLI::process() can now be passed an incomplete array of CLI values -- Missing values will be set to the CLI defaults -- Thanks to Maksim Kochkin for the patch - Fixed bug #20093 : Bug with ternary operator token - Fixed bug #20097 : CLI.php throws error in php 5.2 - Fixed bug #20100 : incorrect Function mysql() has been deprecated report - Fixed bug #20119 : PHP warning: invalid argument to str_repeat() in SVN blame report with -s - Fixed bug #20123 : PSR2 complains about an empty second statement in for-loop - Fixed bug #20131 : PHP errors in svnblame report, if there are files not under version control - Fixed bug #20133 : Allow "HG: hg_id" as value for @version tag 1.5.0RC4 1.5.0RC4 beta beta 2013-09-26 BSD License - You can now restrict violations to individual sniff codes using the --sniffs command line argument -- Previously, this only restricted violations to an entire sniff and not individual messages -- If you have scripts calling PHP_CodeSniffer::process() or creating PHP_CodeSniffer_File objects, you must update your code -- The array of restrictions passed to PHP_CodeSniffer::process() must now be an array of sniff codes instead of class names -- The PHP_CodeSniffer_File::__construct() method now requires an array of restrictions to be passed - Doc generation is now working again - Progress information now shows the percentage complete at the end of each line - Added report type --report=junit to show the error list in a JUnit compatible format -- Thanks to Oleg Lobach for the contribution - Added support for the PHP 5.4 callable type hint - Fixed problem where some file content could be ignored when checking STDIN - Version information is now printed when installed via composer or run from a Git clone (request #20050) - Added Squiz DisallowBooleanStatementSniff to ban boolean operators outside of control structure conditions - The CSS tokenizer is now more reliable when encountering 'list' and 'break' strings - Coding standard ignore comments can now appear instead doc blocks as well as inline comments -- Thanks to Stuart Langley for the patch - Generic LineLengthSniff now ignores SVN URL and Head URL comments -- Thanks to Karl DeBisschop for the patch - PEAR MultiLineConditionSniff now has a setting to specify how many spaces code should be indented -- Default remains at 4; override the 'indent' setting in a ruleset.xml file to change -- Thanks to Szabolcs Sulik for the patch - PEAR MultiLineAssignmentSniff now has a setting to specify how many spaces code should be indented -- Default remains at 4; override the 'indent' setting in a ruleset.xml file to change -- Thanks to Szabolcs Sulik for the patch - PEAR FunctionDeclarationSniff now has a setting to specify how many spaces code should be indented -- Default remains at 4; override the 'indent' setting in a ruleset.xml file to change -- Thanks to Szabolcs Sulik for the patch - Squiz SwitchDeclarationSniff now has a setting to specify how many spaces code should be indented -- Default remains at 4; override the 'indent' setting in a ruleset.xml file to change -- Thanks to Szabolcs Sulik for the patch - Squiz CSS IndentationSniff now has a setting to specify how many spaces code should be indented -- Default remains at 4; override the 'indent' setting in a ruleset.xml file to change -- Thanks to Hugo Fonseca for the patch - Squiz and MySource File and Function comment sniffs now allow all tags and don't require a particular licence - Squiz standard now allows lines to be 120 characters long before warning; up from 85 - Squiz LowercaseStyleDefinitionSniff no longer throws errors for class names in nested style definitions - Squiz ClassFileNameSniff no longer throws errors when checking STDIN - Squiz CSS sniffs no longer generate errors for IE filters - Squiz CSS IndentationSniff no longer sees comments as blank lines - Squiz LogicalOperatorSpacingSniff now ignores whitespace at the end of a line - Squiz.Scope.MethodScope.Missing error message now mentions 'visibility' instead of 'scope modifier' -- Thanks to Renat Akhmedyanov for the patch - Added support for the PSR2 multi-line arguments errata - The PSR2 standard no longer throws errors for additional spacing after a type hint - PSR UseDeclarationSniff no longer throws errors for USE statements inside TRAITs - Fixed cases where code was incorrectly assigned the T_GOTO_LABEL token when used in a complex CASE condition - Fixed bug #20026 : Check for multi-line arrays that should be single-line is slightly wrong -- Adds new error message for single-line arrays that end with a comma - Fixed bug #20029 : ForbiddenFunction sniff incorrectly recognizes methods in USE clauses - Fixed bug #20043 : Mis-interpretation of Foo::class - Fixed bug #20044 : PSR1 camelCase check does not ignore leading underscores - Fixed bug #20045 : Errors about indentation for closures with multi-line 'use' in functions - Fixed bug #20051 : Undefined index: scope_opener / scope_closer -- Thanks to Anthon Pang for the patch 1.5.0RC3 1.5.0RC3 beta beta 2013-07-25 BSD License - Added report type --report=json to show the error list and total counts for all checked files -- Thanks to Jeffrey Fisher for the contribution - PHP_CodeSniffer::isCamelCaps now allows for acronyms at the start of a string if the strict flag is FALSE -- acronyms are defined as at least 2 uppercase characters in a row -- e.g., the following is now valid camel caps with strict set to FALSE: XMLParser - The PHP tokenizer now tokenizes goto labels as T_GOTO_LABEL instead of T_STRING followed by T_COLON - The JS tokenizer now has support for the T_THROW token - Symlinked directories inside CodeSniffer/Standards and in ruleset.xml files are now supported -- Only available since PHP 5.2.11 and 5.3.1 -- Thanks to Maik Penz for the patch - The JS tokenizer now correctly identifies T_INLINE_ELSE tokens instead of leaving them as T_COLON -- Thanks to Arnout Boks for the patch - Explaining a standard (phpcs -e) that uses namespaces now works correctly - Restricting a check to specific sniffs (phpcs --sniffs=...) now works correctly with namespaced sniffs -- Thanks to Maik Penz for the patch - Docs added for the entire Generic standard, and many sniffs from other standards are now documented as well -- Thanks to Spencer Rinehart for the contribution - Clearer error message for when the sniff class name does not match the directory structure - Generated HTML docs now correctly show the open PHP tag in code comparison blocks - Added Generic InlineHTMLSniff to ensure a file only contains PHP code - Added Squiz ShorthandSizeSniff to check that CSS sizes are using shorthand notation only when 1 or 2 values are used - Added Squiz ForbiddenStylesSniff to ban the use of some deprecated browser-specific styles - Added Squiz NamedColoursSniff to ban the use of colour names - PSR2 standard no longer enforces no whitespace between the closing parenthesis of a function call and the semicolon - PSR2 ClassDeclarationSniff now ignores empty classes when checking the end brace position - PSR2 SwitchDeclarationSniff no longer reports errors for empty lines between CASE statements - PEAR ObjectOperatorIndentSniff now has a setting to specify how many spaces code should be indented -- Default remains at 4; override the indent setting in a ruleset.xml file to change -- Thanks to Andrey Mindubaev for the patch - Squiz FileExtensionSniff now supports traits -- Thanks to Lucas Green for the patch - Squiz ArrayDeclarationSniff no longer reports errors for no comma at the end of a line that contains a function call - Squiz SwitchDeclarationSniff now supports T_CONTINUE and T_THROW as valid case/default breaking statements - Squiz CommentedOutCodeSniff is now better at ignoring commented out HTML, XML and regular expressions - Squiz DisallowComparisonAssignmentSniff no longer throws errors for the third expression in a FOR statement - Squiz ColourDefinitionSniff no longer throws errors for some CSS class names - Squiz ControlStructureSpacingSniff now supports all types of CASE/DEFAULT breaking statements - Generic CallTimePassByReferenceSniff now reports errors for functions called using a variable -- Thanks to Maik Penz for the patch - Generic ConstructorNameSniff no longer throws a notice for abstract constructors inside abstract classes -- Thanks to Spencer Rinehart for the patch - Squiz ComparisonOperatorUsageSniff now checks inside elseif statements -- Thanks to Arnout Boks for the patch - Squiz OperatorSpacingSniff now reports errors for no spacing around inline then and else tokens -- Thanks to Arnout Boks for the patch - Fixed bug #19811 : Comments not ignored in all cases in AbstractPatternSniff -- Thanks to Erik Wiffin for the patch - Fixed bug #19892 : ELSE with no braces causes incorrect SWITCH break statement indentation error - Fixed bug #19897 : Indenting warnings in templates not consistent - Fixed bug #19908 : PEAR MultiLineCondition Does Not Apply elseif - Fixed bug #19930 : option --report-file generate an empty file - Fixed bug #19935 : notify-send reports do not vanish in gnome-shell -- Thanks to Christian Weiske for the patch - Fixed bug #19944 : docblock squiz sniff "return void" trips over return in lambda function - Fixed bug #19953 : PSR2 - Spaces before interface name for abstract class - Fixed bug #19956 : phpcs warns for Type Hint missing Resource - Fixed bug #19957 : Does not understand trait method aliasing - Fixed bug #19968 : Permission denied on excluded directory - Fixed bug #19969 : Sniffs with namespace not recognized in reports - Fixed bug #19997 : Class names incorrectly detected as constants 1.5.0RC2 1.5.0RC2 beta beta 2013-04-04 BSD License - Ruleset processing has been rewritten to be more predictable -- Provides much better support for relative paths inside ruleset files -- May mean that sniffs that were previously ignored are now being included when importing external rulesets -- Ruleset processing output can be seen by using the -vv command line argument -- Internal sniff registering functions have all changed, so please review custom scripts - You can now pass multiple coding standards on the command line, comma separated (request #19144) -- Works with built-in or custom standards and rulesets, or a mix of both - You can now exclude directories or whole standards in a ruleset XML file (request #19731) -- e.g., exclude "Generic.Commenting" or just "Generic" -- You can also pass in a path to a directory instead, if you know it - Added Generic LowerCaseKeywordSniff to ensure all PHP keywords are defined in lowercase -- The PSR2 and Squiz standards now use this sniff - Added Generic SAPIUsageSniff to ensure the PHP_SAPI constant is used instead of php_sapi_name() (request #19863) - Squiz FunctionSpacingSniff now has a setting to specify how many lines there should between functions (request #19843) -- Default remains at 2 -- Override the "spacing" setting in a ruleset.xml file to change - Squiz LowercasePHPFunctionSniff no longer throws errors for the limited set of PHP keywords it was checking -- Add a rule for Generic.PHP.LowerCaseKeyword to your ruleset to replicate this functionality - Added support for the PHP 5.4 T_CALLABLE token so it can be used in lower PHP versions - Generic EndFileNoNewlineSniff now supports checking of CSS and JS files - PSR2 SwitchDeclarationSniff now has a setting to specify how many spaces code should be indented -- Default remains at 4; override the indent setting in a ruleset.xml file to change -- Thanks to Asher Snyder for the patch - Generic ScopeIndentSniff now has a setting to specify a list of tokens that should be ignored -- The first token on the line is checked and the whole line is ignored if the token is in the array -- Thanks to Eloy Lafuente for the patch - Squiz LowercaseClassKeywordsSniff now checks for the TRAIT keyword -- Thanks to Anthon Pang for the patch - If you create your own PHP_CodeSniffer object, PHPCS will no longer exit when an unknown argument is found -- This allows you to create wrapper scripts for PHPCS more easily - PSR2 MethodDeclarationSniff no longer generates a notice for methods named "_" -- Thanks to Bart S for the patch - Squiz BlockCommentSniff no longer reports that a blank line between a scope closer and block comment is invalid - Generic DuplicateClassNameSniff no longer reports an invalid error if multiple PHP open tags exist in a file - Generic DuplicateClassNameSniff no longer reports duplicate errors if multiple PHP open tags exist in a file - Fixed bug #19819 : Freeze with syntax error in use statement - Fixed bug #19820 : Wrong message level in Generic_Sniffs_CodeAnalysis_EmptyStatementSniff - Fixed bug #19859 : CodeSniffer::setIgnorePatterns API changed - Fixed bug #19871 : findExtendedClassName doesn't return FQCN on namespaced classes - Fixed bug #19879 : bitwise and operator interpreted as reference by value 1.5.0RC1 1.5.0RC1 beta beta 2013-02-08 BSD License - Reports have been completely rewritten to consume far less memory -- Each report is incrementally written to the file system during a run and then printed out when the run ends -- There is no longer a need to keep the list of errors and warnings in memory during a run - Multi-file sniff support has been removed because they are too memory intensive -- If you have a custom multi-file sniff, you can convert it into a standard sniff quite easily -- See CodeSniffer/Standards/Generic/Sniffs/Classes/DuplicateClassNameSniff.php for an example 1.4.8 1.4.8 stable stable 2013-11-26 BSD License - Generic ScopeIndentSniff now allows for ignored tokens to be set via ruleset.xml files -- E.g., to ignore comments, override a property using: -- name="ignoreIndentationTokens" type="array" value="T_COMMENT,T_DOC_COMMENT" - PSR2 standard now ignores comments when checking indentation rules - Squiz OperatorSpacingSniff no longer throws errors for the ?: short ternary operator -- Thanks to Antoine Musso for the patch - Comment parser now supports non-English characters when splitting comment lines into words -- Thanks to Nik Sun for the patch - Exit statements are now recognised as valid closers for CASE and DEFAULT blocks -- Thanks to Maksim Kochkin for the patch - PHP_CodeSniffer_CLI::process() can now be passed an incomplete array of CLI values -- Missing values will be set to the CLI defaults -- Thanks to Maksim Kochkin for the patch - Fixed bug #20097 : CLI.php throws error in php 5.2 - Fixed bug #20100 : incorrect Function mysql() has been deprecated report - Fixed bug #20119 : PHP warning: invalid argument to str_repeat() in SVN blame report with -s - Fixed bug #20123 : PSR2 complains about an empty second statement in for-loop - Fixed bug #20131 : PHP errors in svnblame report, if there are files not under version control - Fixed bug #20133 : Allow "HG: hg_id" as value for @version tag 1.4.7 1.4.7 stable stable 2013-09-26 BSD License - Added report type --report=junit to show the error list in a JUnit compatible format -- Thanks to Oleg Lobach for the contribution - Added support for the PHP 5.4 callable type hint - Fixed problem where some file content could be ignored when checking STDIN - Version information is now printed when installed via composer or run from a Git clone (request #20050) - The CSS tokenizer is now more reliable when encountering 'list' and 'break' strings - Coding standard ignore comments can now appear instead doc blocks as well as inline comments -- Thanks to Stuart Langley for the patch - Generic LineLengthSniff now ignores SVN URL and Head URL comments -- Thanks to Karl DeBisschop for the patch - PEAR MultiLineConditionSniff now has a setting to specify how many spaces code should be indented -- Default remains at 4; override the 'indent' setting in a ruleset.xml file to change -- Thanks to Szabolcs Sulik for the patch - PEAR MultiLineAssignmentSniff now has a setting to specify how many spaces code should be indented -- Default remains at 4; override the 'indent' setting in a ruleset.xml file to change -- Thanks to Szabolcs Sulik for the patch - PEAR FunctionDeclarationSniff now has a setting to specify how many spaces code should be indented -- Default remains at 4; override the 'indent' setting in a ruleset.xml file to change -- Thanks to Szabolcs Sulik for the patch - Squiz SwitchDeclarationSniff now has a setting to specify how many spaces code should be indented -- Default remains at 4; override the 'indent' setting in a ruleset.xml file to change -- Thanks to Szabolcs Sulik for the patch - Squiz CSS IndentationSniff now has a setting to specify how many spaces code should be indented -- Default remains at 4; override the 'indent' setting in a ruleset.xml file to change -- Thanks to Hugo Fonseca for the patch - Squiz and MySource File and Function comment sniffs now allow all tags and don't require a particular licence - Squiz LowercaseStyleDefinitionSniff no longer throws errors for class names in nested style definitions - Squiz ClassFileNameSniff no longer throws errors when checking STDIN - Squiz CSS sniffs no longer generate errors for IE filters - Squiz CSS IndentationSniff no longer sees comments as blank lines - Squiz LogicalOperatorSpacingSniff now ignores whitespace at the end of a line - Squiz.Scope.MethodScope.Missing error message now mentions 'visibility' instead of 'scope modifier' -- Thanks to Renat Akhmedyanov for the patch - Added support for the PSR2 multi-line arguments errata - The PSR2 standard no longer throws errors for additional spacing after a type hint - PSR UseDeclarationSniff no longer throws errors for USE statements inside TRAITs - Fixed bug #20026 : Check for multi-line arrays that should be single-line is slightly wrong -- Adds new error message for single-line arrays that end with a comma - Fixed bug #20029 : ForbiddenFunction sniff incorrectly recognizes methods in USE clauses - Fixed bug #20043 : Mis-interpretation of Foo::class - Fixed bug #20044 : PSR1 camelCase check does not ignore leading underscores - Fixed bug #20045 : Errors about indentation for closures with multi-line 'use' in functions 1.4.6 1.4.6 stable stable 2013-07-25 BSD License - Added report type --report=json to show the error list and total counts for all checked files -- Thanks to Jeffrey Fisher for the contribution - The JS tokenizer now has support for the T_THROW token - Symlinked directories inside CodeSniffer/Standards and in ruleset.xml files are now supported -- Only available since PHP 5.2.11 and 5.3.1 -- Thanks to Maik Penz for the patch - The JS tokenizer now correctly identifies T_INLINE_ELSE tokens instead of leaving them as T_COLON -- Thanks to Arnout Boks for the patch - Explaining a standard (phpcs -e) that uses namespaces now works correctly - Restricting a check to specific sniffs (phpcs --sniffs=...) now works correctly with namespaced sniffs -- Thanks to Maik Penz for the patch - Docs added for the entire Generic standard, and many sniffs from other standards are now documented as well -- Thanks to Spencer Rinehart for the contribution - Clearer error message for when the sniff class name does not match the directory structure - Generated HTML docs now correctly show the open PHP tag in code comparison blocks - Added Generic InlineHTMLSniff to ensure a file only contains PHP code - Added Squiz ShorthandSizeSniff to check that CSS sizes are using shorthand notation only when 1 or 2 values are used - Added Squiz ForbiddenStylesSniff to ban the use of some deprecated browser-specific styles - Added Squiz NamedColoursSniff to ban the use of colour names - PSR2 standard no longer enforces no whitespace between the closing parenthesis of a function call and the semicolon - PSR2 ClassDeclarationSniff now ignores empty classes when checking the end brace position - PSR2 SwitchDeclarationSniff no longer reports errors for empty lines between CASE statements - PEAR ObjectOperatorIndentSniff now has a setting to specify how many spaces code should be indented -- Default remains at 4; override the indent setting in a ruleset.xml file to change -- Thanks to Andrey Mindubaev for the patch - Squiz FileExtensionSniff now supports traits -- Thanks to Lucas Green for the patch - Squiz ArrayDeclarationSniff no longer reports errors for no comma at the end of a line that contains a function call - Squiz SwitchDeclarationSniff now supports T_CONTINUE and T_THROW as valid case/default breaking statements - Squiz CommentedOutCodeSniff is now better at ignoring commented out HTML, XML and regular expressions - Squiz DisallowComparisonAssignmentSniff no longer throws errors for the third expression in a FOR statement - Squiz ColourDefinitionSniff no longer throws errors for some CSS class names - Squiz ControlStructureSpacingSniff now supports all types of CASE/DEFAULT breaking statements - Generic CallTimePassByReferenceSniff now reports errors for functions called using a variable -- Thanks to Maik Penz for the patch - Generic ConstructorNameSniff no longer throws a notice for abstract constructors inside abstract classes -- Thanks to Spencer Rinehart for the patch - Squiz ComparisonOperatorUsageSniff now checks inside elseif statements -- Thanks to Arnout Boks for the patch - Squiz OperatorSpacingSniff now reports errors for no spacing around inline then and else tokens -- Thanks to Arnout Boks for the patch - Fixed bug #19811 : Comments not ignored in all cases in AbstractPatternSniff -- Thanks to Erik Wiffin for the patch - Fixed bug #19892 : ELSE with no braces causes incorrect SWITCH break statement indentation error - Fixed bug #19897 : Indenting warnings in templates not consistent - Fixed bug #19908 : PEAR MultiLineCondition Does Not Apply elseif - Fixed bug #19913 : Running phpcs in interactive mode causes warnings -- Thanks to Harald Franndorfer for the patch - Fixed bug #19935 : notify-send reports do not vanish in gnome-shell -- Thanks to Christian Weiske for the patch - Fixed bug #19944 : docblock squiz sniff "return void" trips over return in lambda function - Fixed bug #19953 : PSR2 - Spaces before interface name for abstract class - Fixed bug #19956 : phpcs warns for Type Hint missing Resource - Fixed bug #19957 : Does not understand trait method aliasing - Fixed bug #19968 : Permission denied on excluded directory - Fixed bug #19969 : Sniffs with namespace not recognized in reports - Fixed bug #19997 : Class names incorrectly detected as constants 1.4.5 1.4.5 stable stable 2013-04-04 BSD License - Added Generic LowerCaseKeywordSniff to ensure all PHP keywords are defined in lowercase -- The PSR2 and Squiz standards now use this sniff - Added Generic SAPIUsageSniff to ensure the PHP_SAPI constant is used instead of php_sapi_name() (request #19863) - Squiz FunctionSpacingSniff now has a setting to specify how many lines there should between functions (request #19843) -- Default remains at 2 -- Override the "spacing" setting in a ruleset.xml file to change - Squiz LowercasePHPFunctionSniff no longer throws errors for the limited set of PHP keywords it was checking -- Add a rule for Generic.PHP.LowerCaseKeyword to your ruleset to replicate this functionality - Added support for the PHP 5.4 T_CALLABLE token so it can be used in lower PHP versions - Generic EndFileNoNewlineSniff now supports checking of CSS and JS files - PSR2 SwitchDeclarationSniff now has a setting to specify how many spaces code should be indented -- Default remains at 4; override the indent setting in a ruleset.xml file to change -- Thanks to Asher Snyder for the patch - Generic ScopeIndentSniff now has a setting to specify a list of tokens that should be ignored -- The first token on the line is checked and the whole line is ignored if the token is in the array -- Thanks to Eloy Lafuente for the patch - Squiz LowercaseClassKeywordsSniff now checks for the TRAIT keyword -- Thanks to Anthon Pang for the patch - If you create your own PHP_CodeSniffer object, PHPCS will no longer exit when an unknown argument is found -- This allows you to create wrapper scripts for PHPCS more easily - PSR2 MethodDeclarationSniff no longer generates a notice for methods named "_" -- Thanks to Bart S for the patch - Squiz BlockCommentSniff no longer reports that a blank line between a scope closer and block comment is invalid - Generic DuplicateClassNameSniff no longer reports an invalid error if multiple PHP open tags exist in a file - Generic DuplicateClassNameSniff no longer reports duplicate errors if multiple PHP open tags exist in a file - Fixed bug #19819 : Freeze with syntax error in use statement - Fixed bug #19820 : Wrong message level in Generic_Sniffs_CodeAnalysis_EmptyStatementSniff - Fixed bug #19859 : CodeSniffer::setIgnorePatterns API changed - Fixed bug #19871 : findExtendedClassName doesn't return FQCN on namespaced classes - Fixed bug #19879 : bitwise and operator interpreted as reference by value 1.4.4 1.4.4 stable stable 2013-02-07 BSD License - Ignored lines no longer cause the summary report to show incorrect error and warning counts -- Thanks to Bert Van Hauwaert for the patch - Added Generic CSSLintSniff to run CSSLint over a CSS file and report warnings -- Set full command to run CSSLint using phpcs --config-set csslint_path /path/to/csslint -- Thanks to Roman Levishchenko for the contribution - Added PSR2 ControlStructureSpacingSniff to ensure there are no spaces before and after parenthesis in control structures -- Fixes bug #19732 : PSR2: some control structures errors not reported - Squiz commenting sniffs now support non-English characters when checking for capital letters -- Thanks to Roman Levishchenko for the patch - Generic EndFileNewlineSniff now supports JS and CSS files -- Thanks to Denis Ryabkov for the patch - PSR1 SideEffectsSniff no longer reports constant declarations as side effects - Notifysend report now supports notify-send versions before 0.7.3 -- Thanks to Ken Guest for the patch - PEAR and Squiz FunctionCommentSniffs no longer report errors for misaligned argument comments when they are blank -- Thanks to Thomas Peterson for the patch - Squiz FunctionDeclarationArgumentSpacingSniff now works correctly for equalsSpacing values greater than 0 -- Thanks to Klaus Purer for the patch - Squiz SuperfluousWhitespaceSniff no longer throws errors for CSS files with no newline at the end - Squiz SuperfluousWhitespaceSniff now allows a single newline at the end of JS and CSS files - Fixed bug #19755 : Token of T_CLASS type has no scope_opener and scope_closer keys - Fixed bug #19759 : Squiz.PHP.NonExecutableCode fails for return function()... - Fixed bug #19763 : Use statements for traits not recognised correctly for PSR2 code style - Fixed bug #19764 : Instead of for traits throws uppercase constant name errors - Fixed bug #19772 : PSR2_Sniffs_Namespaces_UseDeclarationSniff does not properly recognize last use - Fixed bug #19775 : False positive in NonExecutableCode sniff when not using curly braces - Fixed bug #19782 : Invalid found size functions in loop when using object operator - Fixed bug #19799 : config folder is not created automatically - Fixed bug #19804 : JS Tokenizer wrong /**/ parsing 1.4.3 1.4.3 stable stable 2012-12-04 BSD License - Added support for the PHP 5.5 T_FINALLY token to detect try/catch/finally statements - Added empty CodeSniffer.conf to enable config settings for Composer installs - Added Generic EndFileNoNewlineSniff to ensure there is no newline at the end of a file - Autoloader can now load PSR-0 compliant classes -- Thanks to Maik Penz for the patch - Squiz NonExecutableCodeSniff no longer throws error for multi-line RETURNs inside CASE statements -- Thanks to Marc Ypes for the patch - Squiz OperatorSpacingSniff no longer reports errors for negative numbers inside inline THEN statements -- Thanks to Klaus Purer for the patch - Squiz OperatorSpacingSniff no longer reports errors for the assignment of operations involving negative numbers - Squiz SelfMemberReferenceSniff can no longer get into an infinite loop when checking a static call with a namespace -- Thanks to Andy Grunwald for the patch - Fixed bug #19699 : Generic.Files.LineLength giving false positives when tab-width is used - Fixed bug #19726 : Wrong number of spaces expected after instanceof static - Fixed bug #19727 : PSR2: no error reported when using } elseif { 1.4.2 1.4.2 stable stable 2012-11-09 BSD License - PHP_CodeSniffer can now be installed using Composer -- Require squizlabs/php_codesniffer in your composer.json file -- Thanks to Rob Bast, Stephen Rees-Carter, Stefano Kowalke and Ivan Habunek for help with this - Squiz BlockCommentSniff and InlineCommentSniff no longer report errors for trait block comments - Squiz SelfMemberReferenceSniff now supports namespaces -- Thanks to Andy Grunwald for the patch - Squiz FileCommentSniff now uses tag names inside the error codes for many messages -- This allows you to exclude specific missing, out of order etc., tags - Squiz SuperfluousWhitespaceSniff now has an option to ignore blank lines -- This will stop errors being reported for lines that contain only whitespace -- Set the ignoreBlankLines property to TRUE in your ruleset.xml file to enable this - PSR2 no longer reports errors for whitespace at the end of blank lines - Fixed gitblame report not working on Windows -- Thanks to Rogerio Prado de Jesus - Fixed an incorrect error in Squiz OperatorSpacingSniff for default values inside a closure definition - Fixed bug #19691 : SubversionPropertiesSniff fails to find missing properties -- Thanks to Kevin Winahradsky for the patch - Fixed bug #19692 : DisallowMultipleAssignments is triggered by a closure - Fixed bug #19693 : exclude-patterns no longer work on specific messages - Fixed bug #19694 : Squiz.PHP.LowercasePHPFunctions incorrectly matches return by ref functions 1.4.1 1.4.1 stable stable 2012-11-02 BSD License - All ignore patterns have been reverted to being checked against the absolute path of a file -- Patterns can be specified to be relative in a ruleset.xml file, but nowhere else -- e.g., [exclude-pattern type="relative"]^tests/*[/exclude-pattern] (with angle brackets, not square brackets) - Added support for PHP tokenizing of T_INLINE_ELSE colons, so this token type is now available -- Custom sniffs that rely on looking for T_COLON tokens inside inline if statements must be changed to use the new token -- Fixes bug #19666 : PSR1.Files.SideEffects throws a notice Undefined index: scope_closer - Messages can now be changed from errors to warnings (and vice versa) inside ruleset.xml files -- As you would with "message" and "severity", specify a "type" tag under a "rule" tag and set the value to "error" or "warning" - PHP_CodeSniffer will now generate a warning on files that it detects have mixed line endings -- This warning has the code Internal.LineEndings.Mixed and can be overridden in a ruleset.xml file -- Thanks to Vit Brunner for help with this - Sniffs inside PHP 5.3 namespaces are now supported, along with the existing underscore-style emulated namespaces -- For example: namespace MyStandard\Sniffs\Arrays; class ArrayDeclarationSniff implements \PHP_CodeSniffer_Sniff { ... -- Thanks to Till Klampaeckel for the patch - Generic DuplicateClassNameSniff is no longer a multi-file sniff, so it won't max out your memory -- Multi-file sniff support should be considered deprecated as standard sniffs can now do the same thing - Added Generic DisallowSpaceIndent to check that files are indented using tabs - Added Generic OneClassPerFileSniff to check that only one class is defined in each file -- Thanks to Andy Grunwald for the contribution - Added Generic OneInterfacePerFileSniff to check that only one interface is defined in each file -- Thanks to Andy Grunwald for the contribution - Added Generic LowercasedFilenameSniff to check that filenames are lowercase -- Thanks to Andy Grunwald for the contribution - Added Generic ClosingPHPTagSniff to check that each open PHP tag has a corresponding close tag -- Thanks to Andy Grunwald for the contribution - Added Generic CharacterBeforePHPOpeningTagSniff to check that the open PHP tag is the first content in a file -- Thanks to Andy Grunwald for the contribution - Fixed incorrect errors in Squiz OperatorBracketSniff and OperatorSpacingSniff for negative numbers in CASE statements -- Thanks to Arnout Boks for the patch - Generic CamelCapsFunctionNameSniff no longer enforces exact case matching for PHP magic methods - Generic CamelCapsFunctionNameSniff no longer throws errors for overridden SOAPClient methods prefixed with double underscores -- Thanks to Dorian Villet for the patch - PEAR ValidFunctionNameSniff now supports traits - PSR1 ClassDeclarationSniff no longer throws an error for non-namespaced code if PHP version is less than 5.3.0 - Fixed bug #19616 : Nested switches cause false error in PSR2 - Fixed bug #19629 : PSR2 error for inline comments on multi-line argument lists - Fixed bug #19644 : Alternative syntax, e.g. if/endif triggers Inline Control Structure error - Fixed bug #19655 : Closures reporting as multi-line when they are not - Fixed bug #19675 : Improper indent of nested anonymous function bodies in a call - Fixed bug #19685 : PSR2 catch-22 with empty third statement in for loop - Fixed bug #19687 : Anonymous functions inside arrays marked as indented incorrectly in PSR2 1.4.0 1.4.0 stable stable 2012-09-26 BSD License - Added PSR1 and PSR2 coding standards that can be used to check your code against these guidelines - PHP 5.4 short array syntax is now detected and tokens are assigned to the open and close characters -- New tokens are T_OPEN_SHORT_ARRAY and T_CLOSE_SHORT_ARRAY as PHP does not define its own - Added the ability to explain a coding standard by listing the sniffs that it includes -- The sniff list includes all imported and native sniffs -- Explain a standard by using the -e and --standard=[standard] command line arguments -- E.g., phpcs -e --standard=Squiz -- Thanks to Ben Selby for the idea - Added report to show results using notify-send -- Use --report=notifysend to generate the report -- Thanks to Christian Weiske for the contribution - The JS tokenizer now recognises RETURN as a valid closer for CASE and DEFAULT inside switch statements - AbstractPatternSniff now sets the ignoreComments option using a public var rather than through the constructor -- This allows the setting to be overwritten in ruleset.xml files -- Old method remains for backwards compatibility - Generic LowerCaseConstantSniff and UpperCaseConstantSniff no longer report errors on classes named True, False or Null - PEAR ValidFunctionNameSniff no longer enforces exact case matching for PHP magic methods - Squiz SwitchDeclarationSniff now allows RETURN statements to close a CASE or DEFAULT statement - Squiz BlockCommentSniff now correctly reports an error for blank lines before blocks at the start of a control structure - Fixed a PHP notice generated when loading custom array settings from a ruleset.xml file - Fixed bug #17908 : CodeSniffer does not recognise optional @params -- Thanks to Pete Walker for the patch - Fixed bug #19538 : Function indentation code sniffer checks inside short arrays - Fixed bug #19565 : Non-Executable Code Sniff Broken for Case Statements with both return and break - Fixed bug #19612 : Invalid @package suggestion 1.3.6 1.3.6 stable stable 2012-08-08 BSD License - Memory usage has been dramatically reduced when using the summary report -- Reduced memory is only available when displaying a single summary report to the screen -- PHP_CodeSniffer will not generate any messages in this case, storing only error counts instead -- Impact is most notable with very high error and warning counts - Significantly improved the performance of Squiz NonExecutableCodeSniff - Ignore patterns now check the relative path of a file based on the dir being checked -- Allows ignore patterns to become more generic as the path to the code is no longer included when checking -- Thanks to Kristof Coomans for the patch - Sniff settings can now be changed by specifying a special comment format inside a file -- e.g., // @codingStandardsChangeSetting PEAR.Functions.FunctionCallSignature allowMultipleArguments false -- If you change a setting, don't forget to change it back - Added Generic EndFileNewlineSniff to ensure PHP files end with a newline character - PEAR FunctionCallSignatureSniff now includes a setting to force one argument per line in multi-line calls -- Set allowMultipleArguments to false - Squiz standard now enforces one argument per line in multi-line function calls - Squiz FunctionDeclarationArgumentSpacingSniff now supports closures - Squiz OperatorSpacingSniff no longer throws an error for negative values inside an inline THEN statement -- Thanks to Klaus Purer for the patch - Squiz FunctionCommentSniff now throws an error for not closing a comment with */ -- Thanks to Klaus Purer for the patch - Summary report no longer shows two lines of PHP_Timer output when showing sources - Fixed undefined variable error in PEAR FunctionCallSignatureSniff for lines with no indent - Fixed bug #19502 : Generic.Files.LineEndingsSniff fails if no new-lines in file - Fixed bug #19508 : switch+return: Closing brace indented incorrectly - Fixed bug #19532 : The PSR-2 standard don't recognize Null in class names - Fixed bug #19546 : Error thrown for __call() method in traits 1.3.5 1.3.5 stable stable 2012-07-12 BSD License - Added Generic CamelCapsFunctionNameSniff to just check if function and method names use camel caps -- Does not allow underscore prefixes for private/protected methods -- Defaults to strict checking, where two uppercase characters can not be next to each other -- Strict checking can be disabled in a ruleset.xml file - Squiz FunctionDeclarationArgumentSpacing now has a setting to specify how many spaces should surround equals signs -- Default remains at 0 -- Override the equalsSpacing setting in a ruleset.xml file to change - Squiz ClassDeclarationSniff now throws errors for > 1 space before extends/implements class name with ns separator - Squiz standard now warns about deprecated functions using Generic DeprecatedFunctionsSniff - PEAR FunctionDeclarationSniff now reports an error for multiple spaces after the FUNCTION keyword and around USE - PEAR FunctionDeclarationSniff now supports closures - Squiz MultiLineFunctionDeclarationSniff now supports closures - Exclude rules written for Unix systems will now work correctly on Windows -- Thanks to Walter Tamboer for the patch - The PHP tokenizer now recognises T_RETURN as a valid closer for T_CASE and T_DEFAULT inside switch statements - Fixed duplicate message codes in Generic OpeningFunctionBraceKernighanRitchieSniff - Fixed bug #18651 : PHPunit Test cases for custom standards are not working on Windows - Fixed bug #19416 : Shorthand arrays cause bracket spacing errors - Fixed bug #19421 : phpcs doesn't recognize ${x} as equivalent to $x - Fixed bug #19428 : PHPCS Report "hgblame" doesn't support windows paths -- Thanks to Justin Rovang for the patch - Fixed bug #19448 : Problem with detecting remote standards - Fixed bug #19463 : Anonymous functions incorrectly being flagged by NonExecutableCodeSniff - Fixed bug #19469 : PHP_CodeSniffer_File::getMemberProperties() sets wrong scope - Fixed bug #19471 : phpcs on Windows, when using Zend standard, doesn't catch problems -- Thanks to Ivan Habunek for the patch - Fixed bug #19478 : Incorrect indent detection in PEAR standard -- Thanks to Shane Auckland for the patch - Fixed bug #19483 : Blame Reports fail with space in directory name 1.3.4 1.3.4 stable stable 2012-05-17 BSD License - Added missing package.xml entries for new Generic FixmeSniff -- Thanks to Jaroslav Hanslík for the patch - Expected indents for PEAR ScopeClosingBraceSniff and FunctionCallSignatureSniff can now be set in ruleset files -- Both sniffs use a variable called "indent" -- Thanks to Thomas Despoix for the patch - Standards designed to be installed in the PHPCS Standards dir will now work outside this dir as well -- In particular, allows the Drupal CS to work without needing to symlink it into the PHPCS install -- Thanks to Peter Philipp for the patch - Rule references for standards, directories and specific sniffs can now be relative in ruleset.xml files -- For example: ref="../MyStandard/Sniffs/Commenting/DisallowHashCommentsSniff.php" - Symlinked standards now work correctly, allowing aliasing of installed standards (request #19417) -- Thanks to Tom Klingenberg for the patch - Squiz ObjectInstantiationSniff now allows objects to be returned without assigning them to a variable - Added Squiz.Commenting.FileComment.MissingShort error message for file comments that only contains tags -- Also stops undefined index errors being generated for these comments - Debug option -vv now shows tokenizer status for CSS files - Added support for new gjslint error formats -- Thanks to Meck for the patch - Generic ScopeIndentSniff now allows comment indents to not be exact even if the exact flag is set -- The start of the comment is still checked for exact indentation as normal - Fixed an issue in AbstractPatternSniff where comments were not being ignored in some cases - Fixed an issue in Zend ClosingTagSniff where the closing tag was not always being detected correctly -- Thanks to Jonathan Robson for the patch - Fixed an issue in Generic FunctionCallArgumentSpacingSniff where closures could cause incorrect errors - Fixed an issue in Generic UpperCaseConstantNameSniff where errors were incorrectly reported on goto statements -- Thanks to Tom Klingenberg for the patch - PEAR FileCommentSniff and ClassCommentSniff now support author emails with a single character in the local part -- E.g., a@me.com -- Thanks to Denis Shapkin for the patch - Fixed bug #19290 : Generic indent sniffer fails for anonymous functions - Fixed bug #19324 : Setting show_warnings configuration option does not work - Fixed bug #19354 : Not recognizing references passed to method - Fixed bug #19361 : CSS tokenizer generates errors when PHP embedded in CSS file - Fixed bug #19374 : HEREDOC/NOWDOC Indentation problems - Fixed bug #19381 : traits and indentations in traits are not handled properly - Fixed bug #19394 : Notice in NonExecutableCodeSniff - Fixed bug #19402 : Syntax error when executing phpcs on Windows with parens in PHP path -- Thanks to Tom Klingenberg for the patch - Fixed bug #19411 : magic method error on __construct() -- The fix required a rewrite of AbstractScopeSniff, so please test any sniffs that extend this class - Fixed bug #19412 : Incorrect error about assigning objects to variables when inside inline IF - Fixed bug #19413 : php_cs thinks I haven't used a parameter when I have - Fixed bug #19414 : php_cs seems to not track variables correctly in heredocs 1.3.3 1.3.3 stable stable 2012-02-17 BSD License - Added new Generic FixmeSniff that shows error messages for all FIXME comments left in your code -- Thanks to Sam Graham for the contribution - The maxPercentage setting in the Squiz CommentedOutCodeSniff can now be overridden in a ruleset.xml file -- Thanks to Volker Dusch for the patch - The Checkstyle and XML reports now use XMLWriter -- Only change in output is that empty file tags are no longer produced for files with no violations -- Thanks to Sebastian Bergmann for the patch - Added PHP_CodeSniffer_Tokens::$bracketTokens to give sniff writers fast access to open and close bracket tokens - Fixed an issue in AbstractPatternSniff where EOL tokens were not being correctly checked in some cases - PHP_CodeSniffer_File::getTokensAsString() now detects incorrect length value (request #19313) - Fixed bug #19114 : CodeSniffer checks extension even for single file - Fixed bug #19171 : Show sniff codes option is ignored by some report types -- Thanks to Dominic Scheirlinck for the patch - Fixed bug #19188 : Lots of PHP Notices when analyzing the Symfony framework -- First issue was list-style.. lines in CSS files not properly adjusting open/close bracket positions -- Second issue was notices caused by bug #19137 - Fixed bug #19208 : UpperCaseConstantName reports class members -- Was also a problem with LowerCaseConstantName as well - Fixed bug #19256 : T_DOC_COMMENT in CSS files breaks ClassDefinitionNameSpacingSniff -- Thanks to Klaus Purer for the patch - Fixed bug #19264 : Squiz.PHP.NonExecutableCode does not handle RETURN in CASE without BREAK - Fixed bug #19270 : DuplicateClassName does not handle namespaces correctly - Fixed bug #19283 : CSS @media rules cause false positives -- Thanks to Klaus Purer for the patch 1.3.2 1.3.2 stable stable 2011-12-01 BSD License - Added Generic JSHintSniff to run jshint.js over a JS file and report warnings -- Set jshint path using phpcs --config-set jshint_path /path/to/jshint-rhino.js -- Set rhino path using phpcs --config-set rhino_path /path/to/rhino -- Thanks to Alexander Weiß for the contribution - Nowdocs are now tokenized using PHP_CodeSniffer specific T_NOWDOC tokens for easier identification - Generic UpperCaseConstantNameSniff no longer throws errors for namespaces -- Thanks to Jaroslav Hanslík for the patch - Squiz NonExecutableCodeSniff now detects code after thrown exceptions -- Thanks to Jaroslav Hanslík for the patch - Squiz OperatorSpacingSniff now ignores references -- Thanks to Jaroslav Hanslík for the patch - Squiz FunctionCommentSniff now reports a missing function comment if it finds a standard code comment instead - Squiz FunctionCommentThrownTagSniff no longer reports errors if it can't find a function comment - Fixed unit tests not running under Windows -- Thanks to Jaroslav Hanslík for the patch - Fixed bug #18964 : "$stackPtr must be of type T_VARIABLE" on heredocs and nowdocs - Fixed bug #18973 : phpcs is looking for variables in a nowdoc - Fixed bug #18974 : Blank line causes "Multi-line function call not indented correctly" -- Adds new error message to ban empty lines in multi-line function calls - Fixed bug #18975 : "Closing parenthesis must be on a line by itself" also causes indentation error 1.3.1 1.3.1 stable stable 2011-11-03 BSD License - All report file command line arguments now work with relative paths (request #17240) - The extensions command line argument now supports multi-part file extensions (request #17227) - Added report type --report=hgblame to show number of errors/warnings committed by authors in a Mercurial repository -- Has the same functionality as the svnblame report -- Thanks to Ben Selby for the patch - Added T_BACKTICK token type to make detection of backticks easier (request #18799) - Added pattern matching support to Generic ForbiddenFunctionsSniff -- If you are extending it and overriding register() or addError() you will need to review your sniff - Namespaces are now recognised as scope openers, although they do not require braces (request #18043) - Added new ByteOrderMarkSniff to Generic standard (request #18194) -- Throws an error if a byte order mark is found in any PHP file -- Thanks to Piotr Karas for the contribution - PHP_Timer output is no longer included in reports when being written to a file (request #18252) -- Also now shown for all report types if nothing is being printed to the screen - Generic DeprecatedFunctionSniff now reports functions as deprecated and not simply forbidden (request #18288) - PHPCS now accepts file contents from STDIN (request #18447) -- Example usage: cat temp.php | phpcs [options] -OR- phpcs [options] < temp.php -- Not every sniff will work correctly due to the lack of a valid file path - PHP_CodeSniffer_Exception no longer extends PEAR_Exception (request #18483) -- PEAR_Exception added a requirement that PEAR had to be installed -- PHP_CodeSniffer is not used as a library, so unlikely to have any impact - PEAR FileCommentSniff now allows GIT IDs in the version tag (request #14874) - AbstractVariableSniff now supports heredocs -- Also includes some variable detection fixes -- Thanks to Sam Graham for the patch - Squiz FileCommentSniff now enforces rule that package names cannot start with the word Squiz - MySource AssignThisSniff now allows "this" to be assigned to the private var _self - Fixed issue in Squiz FileCommentSniff where suggested package name was the same as the incorrect package name - Fixed some issues with Squiz ArrayDeclarationSniff when using function calls in array values - Fixed doc generation so it actually works again -- Also now works when being run from an SVN checkout as well as when installed as a PEAR package -- Should fix bug #18949 : Call to private method from static - PEAR ClassDeclaration sniff now supports indentation checks when using the alternate namespace syntax -- PEAR.Classes.ClassDeclaration.SpaceBeforeBrace message now contains 2 variables instead of 1 -- Sniff allows overriding of the default indent level, which is set to 4 -- Fixes bug #18933 : Alternative namespace declaration syntax confuses scope sniffs - Fixed bug #18465 : "self::" does not work in lambda functions -- Also corrects conversion of T_FUNCTION tokens to T_CLOSURE, which was not fixing token condition arrays - Fixed bug #18543 : CSS Tokenizer deletes too many # - Fixed bug #18624 : @throws namespace problem -- Thanks to Gavin Davies for the patch - Fixed bug #18628 : Generic.Files.LineLength gives incorrect results with Windows line-endings - Fixed bug #18633 : CSS Tokenizer doesn't replace T_LIST tokens inside some styles - Fixed bug #18657 : anonymous functions wrongly indented - Fixed bug #18670 : UpperCaseConstantNameSniff fails on dynamic retrieval of class constant - Fixed bug #18709 : Code sniffer sniffs file if even if it's in --ignore -- Thanks to Artem Lopata for the patch - Fixed bug #18762 : Incorrect handling of define and constant in UpperCaseConstantNameSniff -- Thanks to Thomas Baker for the patch - Fixed bug #18769 : CSS Tokenizer doesn't replace T_BREAK tokens inside some styles - Fixed bug #18835 : Unreachable errors of inline returns of closure functions -- Thanks to Patrick Schmidt for the patch - Fixed bug #18839 : Fix miscount of warnings in AbstractSniffUnitTest.php -- Thanks to Sam Graham for the patch - Fixed bug #18844 : Generic_Sniffs_CodeAnalysis_UnusedFunctionParameterSniff with empty body -- Thanks to Dmitri Medvedev for the patch - Fixed bug #18847 : Running Squiz_Sniffs_Classes_ClassDeclarationSniff results in PHP notice - Fixed bug #18868 : jslint+rhino: errors/warnings not detected -- Thanks to Christian Weiske for the patch - Fixed bug #18879 : phpcs-svn-pre-commit requires escapeshellarg -- Thanks to Bjorn Katuin for the patch - Fixed bug #18951 : weird behaviour with closures and multi-line use () params 1.3.0 1.3.0 stable stable 2011-03-17 BSD License - Add a new token T_CLOSURE that replaces T_FUNCTION if the function keyword is anonymous - Many Squiz sniffs no longer report errors when checking closures; they are now ignored - Fixed some error messages in PEAR MultiLineConditionSniff that were not using placeholders for message data - AbstractVariableSniff now correctly finds variable names wrapped with curly braces inside double quoted strings - PEAR FunctionDeclarationSniff now ignores arrays in argument default values when checking multi-line declarations - Fixed bug #18200 : Using custom named ruleset file as standard no longer works - Fixed bug #18196 : PEAR MultiLineCondition.SpaceBeforeOpenBrace not consistent with newline chars - Fixed bug #18204 : FunctionCommentThrowTag picks wrong exception type when throwing function call - Fixed bug #18222 : Add __invoke method to PEAR standard - Fixed bug #18235 : Invalid error generation in Squiz.Commenting.FunctionCommentThrowTag - Fixed bug #18250 : --standard with relative path skips Standards' "implicit" sniffs - Fixed bug #18274 : Multi-line IF and function call indent rules conflict - Fixed bug #18282 : Squiz doesn't handle final keyword before function comments -- Thanks to Dave Perrett for the patch - Fixed bug #18336 : Function isUnderscoreName gives php notices 1.3.0RC2 1.3.0RC2 beta beta 2011-01-14 BSD License - You can now print multiple reports for each run and print each to the screen or a file (request #12434) -- Format is --report-[report][=file] (e.g., --report-xml=out.xml) -- Printing to screen is done by leaving [file] empty (e.g., --report-xml) -- Multiple reports can be specified in this way (e.g., --report-summary --report-xml=out.xml) -- The standard --report and --report-file command line arguments are unchanged - Added -d command line argument to set php.ini settings while running (request #17244) -- Usage is: phpcs -d memory_limit=32M -d ... -- Thanks to Ben Selby for the patch - Added -p command line argument to show progress during a run -- Dot means pass, E means errors found, W means only warnings found and S means skipped file -- Particularly good for runs where you are checking more than 100 files -- Enable by default with --config-set show_progress 1 -- Will not print anything if you are already printing verbose output -- This has caused a big change in the way PHP_CodeSniffer processes files (API changes around processing) - You can now add exclude rules for individual sniffs or error messages (request #17903) -- Only available when using a ruleset.xml file to specify rules -- Uses the same exclude-pattern tags as normal but allows them inside rule tags - Using the -vvv option will now print a list of sniffs executed for each file and how long they took to process - Added Generic ClosureLinterSniff to run Google's gjslint over your JS files - The XML and CSV reports now include the severity of the error (request #18165) -- The Severity column in the CSV report has been renamed to Type, and a new Severity column added for this - Fixed issue with Squiz FunctionCommentSniff reporting incorrect type hint when default value uses namespace -- Thanks to Anti Veeranna for the patch - Generic FileLengthSniff now uses iconv_strlen to check line length if an encoding is specified (request #14237) - Generic UnnecessaryStringConcatSniff now allows strings to be combined to form a PHP open or close tag - Squiz SwitchDeclarationSniff no longer reports indentation errors for BREAK statements inside IF conditions - Interactive mode now always prints the full error report (ignores command line) - Improved regular expression detection in JavaScript files -- Added new T_TYPEOF token that can be used to target the typeof JS operator -- Fixes bug #17611 : Regular expression tokens not recognised - Squiz ScopeIndentSniff removed -- Squiz standard no longer requires additional indents between ob_* methods -- Also removed Squiz OutputBufferingIndentSniff that was checking the same thing - PHP_CodeSniffer_File::getMemberProperties() performance improved significantly -- Improves performance of Squiz ValidVariableNameSniff significantly - Squiz OperatorSpacingSniff performance improved significantly - Squiz NonExecutableCodeSniff performance improved significantly -- Will throw duplicate errors in some cases now, but these should be rare - MySource IncludeSystemSniff performance improved significantly - MySource JoinStringsSniff no longer reports an error when using join() on a named JS array - Warnings are now reported for each file when they cannot be opened instead of stopping the script -- Hide warnings with the -n command line argument -- Can override the warnings using the code Internal.DetectLineEndings - Fixed bug #17693 : issue with pre-commit hook script with filenames that start with v - Fixed bug #17860 : isReference function fails with references in array -- Thanks to Lincoln Maskey for the patch - Fixed bug #17902 : Cannot run tests when tests are symlinked into tests dir -- Thanks to Matt Button for the patch - Fixed bug #17928 : Improve error message for Generic_Sniffs_PHP_UpperCaseConstantSniff -- Thanks to Stefano Kowalke for the patch - Fixed bug #18039 : JS Tokenizer crash when ] is last character in file - Fixed bug #18047 : Incorrect handling of namespace aliases as constants -- Thanks to Dmitri Medvedev for the patch - Fixed bug #18072 : Impossible to exclude path from processing when symlinked - Fixed bug #18073 : Squiz.PHP.NonExecutableCode fault - Fixed bug #18117 : PEAR coding standard: Method constructor not sniffed as a function - Fixed bug #18135 : Generic FunctionCallArgumentSpacingSniff reports function declaration errors - Fixed bug #18140 : Generic scope indent in exact mode: strange expected/found values for switch - Fixed bug #18145 : Sniffs are not loaded for custom ruleset file -- Thanks to Scott McCammon for the patch - Fixed bug #18152 : While and do-while with AbstractPatternSniff - Fixed bug #18191 : Squiz.PHP.LowercasePHPFunctions does not work with new Date() - Fixed bug #18193 : CodeSniffer doesn't reconize CR (\r) line endings 1.3.0RC1 1.3.0RC1 beta beta 2010-09-03 BSD License - Added exclude pattern support to ruleset.xml file so you can specify ignore patterns in a standard (request #17683) -- Use new exclude-pattern tags to include the ignore rules into your ruleset.xml file -- See CodeSniffer/Standards/PHPCS/ruleset.xml for an example - Added new --encoding command line argument to specify the encoding of the files being checked -- When set to utf-8, stops the XML-based reports from double-encoding -- When set to something else, helps the XML-based reports encode to utf-8 -- Default value is iso-8859-1 but can be changed with --config-set encoding [value] - The report is no longer printed to screen when using the --report-file command line option (request #17467) -- If you want to print it to screen as well, use the -v command line argument - The SVN and GIT blame reports now also show percentage of reported errors per author (request #17606) -- Thanks to Ben Selby for the patch - Updated the SVN pre-commit hook to work with the new severity levels feature - Generic SubversionPropertiesSniff now allows properties to have NULL values (request #17682) -- A null value indicates that the property should exist but the value should not be checked - Generic UpperCaseConstantName Sniff now longer complains about the PHPUnit_MAIN_METHOD constant (request #17798) - Squiz FileComment sniff now checks JS files as well as PHP files - Squiz FunctionCommentSniff now supports namespaces in type hints - Fixed a problem in Squiz OutputBufferingIndentSniff where block comments were reported as not indented - Fixed bug #17092 : Problems with utf8_encode and htmlspecialchars with non-ascii chars -- Use the new --encoding=utf-8 command line argument if your files are utf-8 encoded - Fixed bug #17629 : PHP_CodeSniffer_Tokens::$booleanOperators missing T_LOGICAL_XOR -- Thanks to Matthew Turland for the patch - Fixed bug #17699 : Fatal error generating code coverage with PHPUnit 5.3.0RC1 - Fixed bug #17718 : Namespace 'use' statement: used global class name is recognized as constant - Fixed bug #17734 : Generic SubversionPropertiesSniff complains on non SVN files - Fixed bug #17742 : EmbeddedPhpSniff reacts negatively to file without closing php tag - Fixed bug #17823 : Notice: Please no longer include PHPUnit/Framework.php 1.3.0a1 1.3.0a1 alpha alpha 2010-07-15 BSD License - All CodingStandard.php files have been replaced by ruleset.xml files -- Custom standards will need to be converted over to this new format to continue working - You can specify a path to your own custom ruleset.xml file by using the --standard command line arg -- e.g., phpcs --standard=/path/to/my/ruleset.xml - Added a new report type --report=gitblame to show how many errors and warnings were committed by each author -- Has the same functionality as the svnblame report -- Thanks to Ben Selby for the patch - A new token type T_DOLLAR has been added to allow you to sniff for variable variables (feature request #17095) -- Thanks to Ian Young for the patch - JS tokenizer now supports T_POWER (^) and T_MOD_EQUAL (%=) tokens (feature request #17441) - If you have PHP_Timer installed, you'll now get a time/memory summary at the end of a script run -- Only happens when printing reports that are designed to be read on the command line - Added Generic DeprecatedFunctionsSniff to warn about the use of deprecated functions (feature request #16694) -- Thanks to Sebastian Bergmann for the patch - Added Squiz LogicalOperatorSniff to ensure that logical operators are surrounded by single spaces - Added MySource ChannelExceptionSniff to ensure action files only throw ChannelException - Added new method getClassProperties() for sniffs to use to determine if a class is abstract and/or final -- Thanks to Christian Kaps for the patch - Generic UpperCaseConstantSniff no longer throws errors about namespaces -- Thanks to Christian Kaps for the patch - Squiz OperatorBracketSniff now correctly checks value assignments in arrays - Squiz LongConditionClosingCommentSniff now requires a comment for long CASE statements that use curly braces - Squiz LongConditionClosingCommentSniff now requires an exact comment match on the brace - MySource IncludeSystemSniff now ignores DOMDocument usage - MySource IncludeSystemSniff no longer requires inclusion of systems that are being implemented - Removed found and expected messages from Squiz ConcatenationSpacingSniff because they were messy and not helpful - Fixed a problem where Generic CodeAnalysisSniff could show warnings if checking multi-line strings - Fixed error messages in Squiz ArrayDeclarationSniff reporting incorrect number of found and expected spaces - Fixed bug #17048 : False positive in Squiz_WhiteSpace_ScopeKeywordSpacingSniff - Fixed bug #17054 : phpcs more strict than PEAR CS regarding function parameter spacing - Fixed bug #17096 : Notice: Undefined index: scope_condition in ScopeClosingBraceSniff.php -- Moved PEAR.Functions.FunctionCallArgumentSpacing to Generic.Functions.FunctionCallArgumentSpacing - Fixed bug #17144 : Deprecated: Function eregi() is deprecated - Fixed bug #17236 : PHP Warning due to token_get_all() in DoubleQuoteUsageSniff - Fixed bug #17243 : Alternate Switch Syntax causes endless loop of Notices in SwitchDeclaration - Fixed bug #17313 : Bug with switch case structure - Fixed bug #17331 : Possible parse error: interfaces may not include member vars - Fixed bug #17337 : CSS tokenizer fails on quotes urls - Fixed bug #17420 : Uncaught exception when comment before function brace - Fixed bug #17503 : closures formatting is not supported 1.2.2 1.2.2 stable stable 2010-01-27 BSD License - The core PHP_CodeSniffer_File methods now understand the concept of closures (feature request #16866) -- Thanks to Christian Kaps for the sample code - Sniffs can now specify violation codes for each error and warning they add -- Future versions will allow you to override messages and severities using these codes -- Specifying a code is optional, but will be required if you wish to support overriding - All reports have been broken into separate classes -- Command line usage and report output remains the same -- Thanks to Gabriele Santini for the patch - Added an interactive mode that can be enabled using the -a command line argument -- Scans files and stops when it finds a file with errors -- Waits for user input to recheck the file (hopefully you fixed the errors) or skip the file -- Useful for very large code bases where full rechecks take a while - The reports now show the correct number of errors and warnings found - The isCamelCaps method now allows numbers in class names - The JS tokenizer now correctly identifies boolean and bitwise AND and OR tokens - The JS tokenizer now correctly identifies regular expressions used in conditions - PEAR ValidFunctionNameSniff now ignores closures - Squiz standard now uses the PEAR setting of 85 chars for LineLengthSniff - Squiz ControlStructureSpacingSniff now ensure there are no spaces around parentheses - Squiz LongConditionClosingCommentSniff now checks for comments at the end of try/catch statements - Squiz LongConditionClosingCommentSniff now checks validity of comments for short structures if they exist - Squiz IncrementDecrementUsageSniff now has better checking to ensure it only looks at simple variable assignments - Squiz PostStatementCommentSniff no longer throws errors for end function comments - Squiz InlineCommentSniff no longer throws errors for end function comments - Squiz OperatorBracketSniff now allows simple arithmetic operations in SWITCH conditions - Squiz ValidFunctionNameSniff now ignores closures - Squiz MethodScopeSniff now ignores closures - Squiz ClosingDeclarationCommentSniff now ignores closures - Squiz GlobalFunctionSniff now ignores closures - Squiz DisallowComparisonAssignmentSniff now ignores the assigning of arrays - Squiz DisallowObjectStringIndexSniff now allows indexes that contain dots and reserved words - Squiz standard now throws nesting level and cyclomatic complexity errors at much higher levels - Squiz CommentedOutCodeSniff now ignores common comment framing characters - Squiz ClassCommentSniff now ensures the open comment tag is the only content on the first line - Squiz FileCommentSniff now ensures the open comment tag is the only content on the first line - Squiz FunctionCommentSniff now ensures the open comment tag is the only content on the first line - Squiz VariableCommentSniff now ensures the open comment tag is the only content on the first line - Squiz NonExecutableCodeSniff now warns about empty return statements that are not required - Removed ForbiddenStylesSniff from Squiz standard -- It is now in in the MySource standard as BrowserSpecificStylesSniff -- New BrowserSpecificStylesSniff ignores files with browser-specific suffixes - MySource IncludeSystemSniff no longer throws errors when extending the Exception class - MySource IncludeSystemSniff no longer throws errors for the abstract widget class - MySource IncludeSystemSniff and UnusedSystemSniff now allow includes inside IF statements - MySource IncludeSystemSniff no longer throws errors for included widgets inside methods - MySource GetRequestDataSniff now throws errors for using $_FILES - MySource CreateWidgetTypeCallbackSniff now allows return statements in nested functions - MySource DisallowSelfActionsSniff now ignores abstract classes - Fixed a problem with the SVN pre-commit hook for PHP versions without vertical whitespace regex support - Fixed bug #16740 : False positives for heredoc strings and unused parameter sniff - Fixed bug #16794 : ValidLogicalOperatorsSniff doesn't report operators not in lowercase - Fixed bug #16804 : Report filename is shortened too much - Fixed bug #16821 : Bug in Squiz_Sniffs_WhiteSpace_OperatorSpacingSniff -- Thanks to Jaroslav Hanslík for the patch - Fixed bug #16836 : Notice raised when using semicolon to open case - Fixed bug #16855 : Generic standard sniffs incorrectly for define() method - Fixed bug #16865 : Two bugs in Squiz_Sniffs_WhiteSpace_OperatorSpacingSniff -- Thanks to Jaroslav Hanslík for the patch - Fixed bug #16902 : Inline If Declaration bug - Fixed bug #16960 : False positive for late static binding in Squiz/ScopeKeywordSpacingSniff -- Thanks to Jakub Tománek for the patch - Fixed bug #16976 : The phpcs attempts to process symbolic links that don't resolve to files - Fixed bug #17017 : Including one file in the files sniffed alters errors reported for another file 1.2.1 1.2.1 stable stable 2009-11-17 BSD License - Added a new report type --report=svnblame to show how many errors and warnings were committed by each author -- Also shows the percentage of their code that are errors and warnings -- Requires you to have the SVN command in your path -- Make sure SVN is storing usernames and passwords (if required) or you will need to enter them for each file -- You can also use the -s command line argument to see the different types of errors authors are committing -- You can use the -v command line argument to see all authors, even if they have no errors or warnings - Added a new command line argument --report-width to allow you to set the column width of screen reports -- Reports wont accept values less than 70 or else they get too small -- Can also be set via a config var: phpcs --config-set report_width 100 - You can now get PHP_CodeSniffer to ignore a whole file by adding @codingStandardsIgnoreFile in the content -- If you put it in the first two lines the file wont even be tokenized, so it will be much quicker - Reports now print their file lists in alphabetical order - PEAR FunctionDeclarationSniff now reports error for incorrect closing bracket placement in multi-line definitions - Added Generic CallTimePassByReferenceSniff to prohibit the passing of variables into functions by reference -- Thanks to Florian Grandel for the contribution - Added Squiz DisallowComparisonAssignmentSniff to ban the assignment of comparison values to a variable - Added Squiz DuplicateStyleDefinitionSniff to check for duplicate CSS styles in a single class block - Squiz ArrayDeclarationSniff no longer checks the case of array indexes because that is not its job - Squiz PostStatementCommentSniff now allows end comments for class member functions - Squiz InlineCommentSniff now supports the checking of JS files - MySource CreateWidgetTypeCallbackSniff now allows the callback to be passed to another function - MySource CreateWidgetTypeCallbackSniff now correctly ignores callbacks used inside conditions - Generic MultipleStatementAlignmentSniff now enforces a single space before equals sign if max padding is reached - Fixed a problem in the JS tokenizer where regular expressions containing \// were not converted correctly - Fixed a problem tokenizing CSS files where multiple ID targets on a line would look like comments - Fixed a problem tokenizing CSS files where class names containing a colon looked like style definitions - Fixed a problem tokenizing CSS files when style statements had empty url() calls - Fixed a problem tokenizing CSS colours with the letter E in first half of the code - Squiz ColonSpacingSniff now ensures it is only checking style definitions in CSS files and not class names - Squiz DisallowComparisonAssignmentSniff no longer reports errors when assigning the return value of a function - CSS tokenizer now correctly supports multi-line comments - When only the case of var names differ for function comments, the error now indicates the case is different - Fixed an issue with Generic UnnecessaryStringConcatSniff where it incorrectly suggested removing a concat - Fixed bug #16530 : ScopeIndentSniff reports false positive - Fixed bug #16533 : Duplicate errors and warnings - Fixed bug #16563 : Check file extensions problem in phpcs-svn-pre-commit -- Thanks to Kaijung Chen for the patch - Fixed bug #16592 : Object operator indentation incorrect when first operator is on a new line - Fixed bug #16641 : Notice output - Fixed bug #16682 : Squiz_Sniffs_Strings_DoubleQuoteUsageSniff reports string "\0" as invalid - Fixed bug #16683 : Typing error in PHP_CodeSniffer_CommentParser_AbstractParser - Fixed bug #16684 : Bug in Squiz_Sniffs_PHP_NonExecutableCodeSniff - Fixed bug #16692 : Spaces in paths in Squiz_Sniffs_Debug_JavaScriptLintSniff -- Thanks to Jaroslav Hanslík for the patch - Fixed bug #16696 : Spelling error in MultiLineConditionSniff - Fixed bug #16697 : MultiLineConditionSniff incorrect result with inline IF - Fixed bug #16698 : Notice in JavaScript Tokenizer - Fixed bug #16736 : Multi-files sniffs aren't processed when FILE is a single directory -- Thanks to Alexey Shein for the patch - Fixed bug #16792 : Bug in Generic_Sniffs_PHP_ForbiddenFunctionsSniff 1.2.0 1.2.0 stable stable 2009-08-17 BSD License - Installed standards are now favoured over custom standards when using the cmd line arg with relative paths - Unit tests now use a lot less memory while running - Squiz standard now uses Generic EmptyStatementSniff but throws errors instead of warnings - Squiz standard now uses Generic UnusedFunctionParameterSniff - Removed unused ValidArrayIndexNameSniff from the Squiz standard - Fixed bug #16424 : SubversionPropertiesSniff print PHP Warning - Fixed bug #16450 : Constant PHP_CODESNIFFER_VERBOSITY already defined (unit tests) - Fixed bug #16453 : function declaration long line splitted error - Fixed bug #16482 : phpcs-svn-pre-commit ignores extensions parameter 1.2.0RC3 1.2.0RC3 beta beta 2009-07-07 BSD License - You can now use @codingStandardsIgnoreStart and @...End comments to suppress messages (feature request #14002) - A warning is now included for files without any code when short_open_tag is set to Off (feature request #12952) - You can now use relative paths to your custom standards with the --standard cmd line arg (feature request #14967) - You can now override magic methods and functions in PEAR ValidFunctionNameSniff (feature request #15830) - MySource IncludeSystemSniff now recognises widget action classes - MySource IncludeSystemSniff now knows about unit test classes and changes rules accordingly 1.2.0RC2 1.2.0RC2 beta beta 2009-05-25 BSD License - Test suite can now be run using the full path to AllTests.php (feature request #16179) - Fixed bug #15980 : PHP_CodeSniffer change php current directory -- Thanks to Dolly Aswin Harahap for the patch - Fixed bug #16001 : Notice triggered - Fixed bug #16054 : phpcs-svn-pre-commit not showing any errors - Fixed bug #16071 : Fatal error: Uncaught PHP_CodeSniffer_Exception - Fixed bug #16170 : Undefined Offset -1 in MultiLineConditionSniff.php on line 68 - Fixed bug #16175 : Bug in Squiz-IncrementDecrementUsageSniff 1.2.0RC1 1.2.0RC1 beta beta 2009-03-09 BSD License - Reports that are output to a file now include a trailing newline at the end of the file - Fixed sniff names not shown in -vvv token processing output - Added Generic SubversionPropertiesSniff to check that specific svn props are set for files -- Thanks to Jack Bates for the contribution - The PHP version check can now be overridden in classes that extend PEAR FileCommentSniff -- Thanks to Helgi Þormar Þorbjörnsson for the suggestion - Added Generic ConstructorNameSniff to check for PHP4 constructor name usage -- Thanks to Leif Wickland for the contribution - Squiz standard now supports multi-line function and condition sniffs from PEAR standard - Squiz standard now uses Generic ConstructorNameSniff - Added MySource GetRequestDataSniff to ensure REQUEST, GET and POST are not accessed directly - Squiz OperatorBracketSniff now allows square brackets in simple unbracketed operations - Fixed the incorrect tokenizing of multi-line block comments in CSS files - Fixed bug #15383 : Uncaught PHP_CodeSniffer_Exception - Fixed bug #15408 : An unexpected exception has been caught: Undefined offset: 2 - Fixed bug #15519 : Uncaught PHP_CodeSniffer_Exception - Fixed bug #15624 : Pre-commit hook fails with PHP errors - Fixed bug #15661 : Uncaught PHP_CodeSniffer_Exception - Fixed bug #15722 : "declare(encoding = 'utf-8');" leads to "Missing file doc comment" - Fixed bug #15910 : Object operator indention not calculated correctly 1.2.0a1 1.2.0a1 alpha alpha 2008-12-18 BSD License - PHP_CodeSniffer now has a CSS tokenizer for checking CSS files - Added support for a new multi-file sniff that sniffs all processed files at once - Added new output format --report=emacs to output errors using the emacs standard compile output format -- Thanks to Len Trigg for the contribution - Reports can now be written to a file using the --report-file command line argument (feature request #14953) -- The report is also written to screen when using this argument - The CheckStyle, CSV and XML reports now include a source for each error and warning (feature request #13242) -- A new report type --report=source can be used to show you the most common errors in your files - Added new command line argument -s to show error sources in all reports - Added new command line argument --sniffs to specify a list of sniffs to restrict checking to -- Uses the sniff source codes that are optionally displayed in reports - Changed the max width of error lines from 80 to 79 chars to stop blank lines in the default windows cmd window - PHP_CodeSniffer now has a token for an asperand (@ symbol) so sniffs can listen for them -- Thanks to Andy Brockhurst for the patch - Added Generic DuplicateClassNameSniff that will warn if the same class name is used in multiple files -- Not currently used by any standard; more of a multi-file sniff sample than anything useful - Added Generic NoSilencedErrorsSniff that warns if PHP errors are being silenced using the @ symbol -- Thanks to Andy Brockhurst for the contribution - Added Generic UnnecessaryStringConcatSniff that checks for two strings being concatenated - Added PEAR FunctionDeclarationSniff to enforce the new multi-line function declaration PEAR standard - Added PEAR MultiLineAssignmentSniff to enforce the correct indentation of multi-line assignments - Added PEAR MultiLineConditionSniff to enforce the new multi-line condition PEAR standard - Added PEAR ObjectOperatorIndentSniff to enforce the new chained function call PEAR standard - Added MySource DisallowSelfActionSniff to ban the use of self::method() calls in Action classes - Added MySource DebugCodeSniff to ban the use of Debug::method() calls - Added MySource CreateWidgetTypeCallback sniff to check callback usage in widget type create methods - Added Squiz DisallowObjectStringIndexSniff that forces object dot notation in JavaScript files -- Thanks to Sertan Danis for the contribution - Added Squiz DiscouragedFunctionsSniff to warn when using debug functions - Added Squiz PropertyLabelSniff to check whitespace around colons in JS property and label declarations - Added Squiz DuplicatePropertySniff to check for duplicate property names in JS classes - Added Squiz ColonSpacingSniff to check for spacing around colons in CSS style definitions - Added Squiz SemicolonSpacingSniff to check for spacing around semicolons in CSS style definitions - Added Squiz IndentationSniff to check for correct indentation of CSS files - Added Squiz ColourDefinitionSniff to check that CSS colours are defined in uppercase and using shorthand - Added Squiz EmptyStyleDefinitionSniff to check for CSS style definitions without content - Added Squiz EmptyClassDefinitionSniff to check for CSS class definitions without content - Added Squiz ClassDefinitionOpeningBraceSpaceSniff to check for spaces around opening brace of CSS class definitions - Added Squiz ClassDefinitionClosingBraceSpaceSniff to check for a single blank line after CSS class definitions - Added Squiz ClassDefinitionNameSpacingSniff to check for a blank lines inside CSS class definition names - Added Squiz DisallowMultipleStyleDefinitionsSniff to check for multiple style definitions on a single line - Added Squiz DuplicateClassDefinitionSniff to check for duplicate CSS class blocks that can be merged - Added Squiz ForbiddenStylesSniff to check for usage of browser specific styles - Added Squiz OpacitySniff to check for incorrect opacity values in CSS - Added Squiz LowercaseStyleDefinitionSniff to check for styles that are not defined in lowercase - Added Squiz MissingColonSniff to check for style definitions where the colon has been forgotten - Added Squiz MultiLineFunctionDeclarationSniff to check that multi-line declarations contain one param per line - Added Squiz JSLintSniff to check for JS errors using the jslint.js script through Rhino -- Set jslint path using phpcs --config-set jslint_path /path/to/jslint.js -- Set rhino path using phpcs --config-set rhino_path /path/to/rhino - Added Generic TodoSniff that warns about comments that contain the word TODO - Removed MultipleStatementAlignmentSniff from the PEAR standard as alignment is now optional - Generic ForbiddenFunctionsSniff now has protected member var to specify if it should use errors or warnings - Generic MultipleStatementAlignmentSniff now has correct error message if assignment is on a new line - Generic MultipleStatementAlignmentSniff now has protected member var to allow it to ignore multi-line assignments - Generic LineEndingsSniff now supports checking of JS files - Generic LineEndingsSniff now supports checking of CSS files - Generic DisallowTabIndentSniff now supports checking of CSS files - Squiz DoubleQuoteUsageSniff now bans the use of variables in double quoted strings in favour of concatenation - Squiz SuperfluousWhitespaceSniff now supports checking of JS files - Squiz SuperfluousWhitespaceSniff now supports checking of CSS files - Squiz DisallowInlineIfSniff now supports checking of JS files - Squiz SemicolonSpacingSniff now supports checking of JS files - Squiz PostStatementCommentSniff now supports checking of JS files - Squiz FunctionOpeningBraceSpacingSniff now supports checking of JS files - Squiz FunctionClosingBraceSpacingSniff now supports checking of JS files -- Empty JS functions must have their opening and closing braces next to each other - Squiz ControlStructureSpacingSniff now supports checking of JS files - Squiz LongConditionClosingCommentSniff now supports checking of JS files - Squiz OperatorSpacingSniff now supports checking of JS files - Squiz SwitchDeclarationSniff now supports checking of JS files - Squiz CommentedOutCodeSniff now supports checking of CSS files - Squiz DisallowSizeFunctionsInLoopsSniff now supports checking of JS files for the use of object.length - Squiz DisallowSizeFunctionsInLoopsSniff no longer complains about size functions outside of the FOR condition - Squiz ControlStructureSpacingSniff now bans blank lines at the end of a control structure - Squiz ForLoopDeclarationSniff no longer throws errors for JS FOR loops without semicolons - Squiz MultipleStatementAlignmentSniff no longer throws errors if a statement would take more than 8 spaces to align - Squiz standard now uses Generic TodoSniff - Squiz standard now uses Generic UnnecessaryStringConcatSniff - Squiz standard now uses PEAR MultiLineAssignmentSniff - Squiz standard now uses PEAR MultiLineConditionSniff - Zend standard now uses OpeningFunctionBraceBsdAllmanSniff (feature request #14647) - MySource JoinStringsSniff now bans the use of inline array joins and suggests the + operator - Fixed incorrect errors that can be generated from abstract scope sniffs when moving to a new file - Core tokenizer now matches orphaned curly braces in the same way as square brackets - Whitespace tokens at the end of JS files are now added to the token stack - JavaScript tokenizer now identifies properties and labels as new token types - JavaScript tokenizer now identifies object definitions as a new token type and matches curly braces for them - JavaScript tokenizer now identifies DIV_EQUAL and MUL_EQUAL tokens - Improved regular expression detection in the JavaScript tokenizer - Improve AbstractPatternSniff support so it can listen for any token type, not just weighted tokens - Fixed Squiz DoubleQuoteUsageSniff so it works correctly with short_open_tag=Off - Fixed bug #14409 : Output of warnings to log file - Fixed bug #14520 : Notice: Undefined offset: 1 in /usr/share/php/PHP/CodeSniffer/File.php on line - Fixed bug #14637 : Call to processUnknownArguments() misses second parameter $pos -- Thanks to Peter Buri for the patch - Fixed bug #14889 : Lack of clarity: licence or license - Fixed bug #15008 : Nested Parentheses in Control Structure Sniffs - Fixed bug #15091 : pre-commit hook attempts to sniff folders -- Thanks to Bruce Weirdan for the patch - Fixed bug #15124 : AbstractParser.php uses deprecated split() function -- Thanks to Sebastian Bergmann for the patch - Fixed bug #15188 : PHPCS vs HEREDOC strings - Fixed bug #15231 : Notice: Uninitialized string offset: 0 in FileCommentSniff.php on line 555 - Fixed bug #15336 : Notice: Undefined offset: 2 in /usr/share/php/PHP/CodeSniffer/File.php on line 1.1.0 1.1.0 stable stable 2008-07-14 BSD License - PEAR FileCommentSniff now allows tag orders to be overridden in child classes -- Thanks to Jeff Hodsdon for the patch - Added Generic DisallowMultipleStatementsSniff to ensure there is only one statement per line - Squiz standard now uses DisallowMultipleStatementsSniff - Fixed error in Zend ValidVariableNameSniff when checking vars in form: $class->{$var} - Fixed bug #14077 : Fatal error: Uncaught PHP_CodeSniffer_Exception: $stackPtr is not a class member - Fixed bug #14168 : Global Function -> Static Method and __autoload() - Fixed bug #14238 : Line length not checked at last line of a file - Fixed bug #14249 : wrong detection of scope_opener - Fixed bug #14250 : ArrayDeclarationSniff emit warnings at malformed array - Fixed bug #14251 : --extensions option doesn't work 1.1.0RC3 1.1.0RC3 beta beta 2008-07-03 BSD License - PEAR FileCommentSniff now allows tag orders to be overridden in child classes -- Thanks to Jeff Hodsdon for the patch - Added Generic DisallowMultipleStatementsSniff to ensure there is only one statement per line - Squiz standard now uses DisallowMultipleStatementsSniff - Fixed error in Zend ValidVariableNameSniff when checking vars in form: $class->{$var} - Fixed bug #14077 : Fatal error: Uncaught PHP_CodeSniffer_Exception: $stackPtr is not a class member - Fixed bug #14168 : Global Function -> Static Method and __autoload() - Fixed bug #14238 : Line length not checked at last line of a file - Fixed bug #14249 : wrong detection of scope_opener - Fixed bug #14250 : ArrayDeclarationSniff emit warnings at malformed array - Fixed bug #14251 : --extensions option doesn't work 1.1.0RC2 1.1.0RC2 beta beta 2008-06-13 BSD License - Permission denied errors now stop script execution but still display current errors (feature request #14076) - Added Squiz ValidArrayIndexNameSniff to ensure array indexes do not use camel case - Squiz ArrayDeclarationSniff now ensures arrays are not declared with camel case index values - PEAR ValidVariableNameSniff now alerts about a possible parse error for member vars inside an interface - Fixed bug #13921 : js parsing fails for comments on last line of file - Fixed bug #13922 : crash in case of malformed (but tokenized) php file -- PEAR and Squiz ClassDeclarationSniff now throw warnings for possible parse errors -- Squiz ValidClassNameSniff now throws warning for possible parse errors -- Squiz ClosingDeclarationCommentSniff now throws additional warnings for parse errors 1.1.0RC1 1.1.0RC1 beta beta 2008-05-13 BSD License - Added support for multiple tokenizers so PHP_CodeSniffer can check more than just PHP files -- PHP_CodeSniffer now has a JS tokenizer for checking JavaScript files -- Sniffs need to be updated to work with additional tokenizers, or new sniffs written for them - phpcs now exits with status 2 if the tokenizer extension has been disabled (feature request #13269) - Added scripts/phpcs-svn-pre-commit that can be used as an SVN pre-commit hook -- Also reworked the way the phpcs script works to make it easier to wrap it with other functionality -- Thanks to Jack Bates for the contribution - Fixed error in phpcs error message when a supplied file does not exist - Fixed a cosmetic error in AbstractPatternSniff where the "found" string was missing some content - Added sniffs that implement part of the PMD rule catalog to the Generic standard -- Thanks to Manuel Pichler for the contribution of all these sniffs. - Squiz FunctionCommentThrowTagSniff no longer throws errors for function that only throw variables - Generic ScopeIndentSniff now has private member to enforce exact indent matching - Replaced Squiz DisallowCountInLoopsSniff with Squiz DisallowSizeFunctionsInLoopsSniff -- Thanks to Jan Miczaika for the sniff - Squiz BlockCommentSniff now checks inline doc block comments - Squiz InlineCommentSniff now checks inline doc block comments - Squiz BlockCommentSniff now checks for no blank line before first comment in a function - Squiz DocCommentAlignmentSniff now ignores inline doc block comments - Squiz ControlStructureSpacingSniff now ensures no blank lines at the start of control structures - Squiz ControlStructureSpacingSniff now ensures no blank lines between control structure closing braces - Squiz IncrementDecrementUsageSniff now ensures inc/dec ops are bracketed in string concats - Squiz IncrementDecrementUsageSniff now ensures inc/dec ops are not used in arithmetic operations - Squiz FunctionCommentSniff no longer throws errors if return value is mixed but function returns void somewhere - Squiz OperatorBracketSniff no allows function call brackets to count as operator brackets - Squiz DoubleQuoteUsageSniff now supports \x \f and \v (feature request #13365) - Squiz ComparisonOperatorUsageSniff now supports JS files - Squiz ControlSignatureSniff now supports JS files - Squiz ForLoopDeclarationSniff now supports JS files - Squiz OperatorBracketSniff now supports JS files - Squiz InlineControlStructureSniff now supports JS files - Generic LowerCaseConstantSniff now supports JS files - Generic DisallowTabIndentSniff now supports JS files - Generic MultipleStatementAlignmentSniff now supports JS files - Added Squiz ObjectMemberCommaSniff to ensure the last member of a JS object is not followed by a comma - Added Squiz ConstantCaseSniff to ensure the PHP constants are uppercase and JS lowercase - Added Squiz JavaScriptLintSniff to check JS files with JSL -- Set path using phpcs --config-set jsl_path /path/to/jsl - Added MySource FirebugConsoleSniff to ban the use of "console" for JS variable and function names - Added MySource JoinStringsSniff to enforce the use of join() to concatenate JS strings - Added MySource AssignThisSniff to ensure this is only assigned to a var called self - Added MySource DisallowNewWidgetSniff to ban manual creation of widget objects - Removed warning shown in Zend CodeAnalyzerSniff when the ZCA path is not set - Fixed error in Squiz ValidVariableNameSniff when checking vars in the form $obj->$var - Fixed error in Squiz DisallowMultipleAssignmentsSniff when checking vars in the form $obj->$var - Fixed error in Squiz InlineCommentSniff where comments for class constants were seen as inline - Fixed error in Squiz BlockCommentSniff where comments for class constants were not ignored - Fixed error in Squiz OperatorBracketSniff where negative numbers were ignored during comparisons - Fixed error in Squiz FunctionSpacingSniff where functions after member vars reported incorrect spacing - Fixed bug #13062 : Interface comments aren't handled in PEAR standard -- Thanks to Manuel Pichler for the path - Fixed bug #13119 : php minimum requirement need to be fix - Fixed bug #13156 : Bug in Squiz_Sniffs_PHP_NonExecutableCodeSniff - Fixed bug #13158 : Strange behaviour in AbstractPatternSniff - Fixed bug #13169 : Undefined variables - Fixed bug #13178 : Catch exception in File.php - Fixed bug #13254 : Notices output in checkstyle report causes XML issues - Fixed bug #13446 : crash with src of phpMyAdmin -- Thanks to Manuel Pichler for the path 1.1.0a1 1.1.0a1 alpha alpha 2008-04-21 BSD License - Fixed error in PEAR ValidClassNameSniff when checking class names with double underscores - Moved Squiz InlineControlStructureSniff into Generic standard - PEAR standard now throws warnings for inline control structures - Squiz OutputBufferingIndentSniff now ignores the indentation of inline HTML - MySource IncludeSystemSniff now ignores usage of ZipArchive - Removed "function" from error messages for Generic function brace sniffs (feature request #13820) - Generic UpperCaseConstantSniff no longer throws errors for declare(ticks = ...) -- Thanks to Josh Snyder for the patch - Squiz ClosingDeclarationCommentSniff and AbstractVariableSniff now throw warnings for possible parse errors - Fixed bug #13827 : AbstractVariableSniff throws "undefined index" - Fixed bug #13846 : Bug in Squiz.NonExecutableCodeSniff - Fixed bug #13849 : infinite loop in PHP_CodeSniffer_File::findNext() 1.0.1 1.0.1 stable stable 2008-02-04 BSD License - Squiz ArrayDeclarationSniff now throws error if the array keyword is followed by a space - Squiz ArrayDeclarationSniff now throws error for empty multi-line arrays - Squiz ArrayDeclarationSniff now throws error for multi-line arrays with a single value - Squiz DocCommentAlignmentSniff now checks for a single space before tags inside docblocks - Squiz ForbiddenFunctionsSniff now disallows is_null() to force use of (=== NULL) instead - Squiz VariableCommentSniff now continues throwing errors after the first one is found - Squiz SuperfluousWhitespaceSniff now throws errors for multiple blank lines inside functions - MySource IncludedSystemSniff now checks extended class names - MySource UnusedSystemSniff now checks extended and implemented class names - MySource IncludedSystemSniff now supports includeWidget() - MySource UnusedSystemSniff now supports includeWidget() - Added PEAR ValidVariableNameSniff to check that only private member vars are prefixed with an underscore - Added Squiz DisallowCountInLoopsSniff to check for the use of count() in FOR and WHILE loop conditions - Added MySource UnusedSystemSniff to check for included classes that are never used - Fixed a problem that caused the parentheses map to sometimes contain incorrect values - Fixed bug #12767 : Cant run phpcs from dir with PEAR subdir - Fixed bug #12773 : Reserved variables are not detected in strings -- Thanks to Wilfried Loche for the patch - Fixed bug #12832 : Tab to space conversion does not work - Fixed bug #12888 : extra space indentation = Notice: Uninitialized string offset... - Fixed bug #12909 : Default generateDocs function does not work under linux -- Thanks to Paul Smith for the patch - Fixed bug #12957 : PHP 5.3 magic method __callStatic -- Thanks to Manuel Pichler for the patch 1.0.0 1.0.0 stable stable 2007-12-21 BSD License - You can now specify the full path to a coding standard on the command line (feature request #11886) -- This allows you to use standards that are stored outside of PHP_CodeSniffer's own Standard dir -- You can also specify full paths in the CodingStandard.php include and exclude methods -- Classes, dirs and files need to be names as if the standard was part of PHP_CodeSniffer -- Thanks to Dirk Thomas for the doc generator patch and testing - Modified the scope map to keep checking after 3 lines for some tokens (feature request #12561) -- Those tokens that must have an opener (like T_CLASS) now keep looking until EOF -- Other tokens (like T_FUNCTION) still stop after 3 lines for performance - You can now escape commas in ignore patterns so they can be matched in file names -- Thanks to Carsten Wiedmann for the patch - Config data is now cached in a global var so the file system is not hit so often -- You can also set config data temporarily for the script if you are using your own external script -- Pass TRUE as the third argument to PHP_CodeSniffer::setConfigData() - PEAR ClassDeclarationSniff no longer throws errors for multi-line class declarations - Squiz ClassDeclarationSniff now ensures there is one blank line after a class closing brace - Squiz ClassDeclarationSniff now throws errors for a missing end PHP tag after the end class tag - Squiz IncrementDecrementUsageSniff no longer throws errors when -= and += are being used with vars - Squiz SwitchDeclarationSniff now throws errors for switch statements that do not contain a case statement -- Thanks to Sertan Danis for the patch - MySource IncludeSystemSniff no longer throws errors for the Util package - Fixed bug #12621 : "space after AS" check is wrong -- Thanks to Satoshi Oikawa for the patch - Fixed bug #12645 : error message is wrong -- Thanks to Renoiv for the patch - Fixed bug #12651 : Increment/Decrement Operators Usage at -1 1.0.0RC3 1.0.0RC3 beta beta 2007-11-30 BSD License - Added new command line argument --tab-width that will convert tabs to spaces before testing -- This allows you to use the existing sniffs that check for spaces even when you use tabs -- Can also be set via a config var: phpcs --config-set tab_width 4 -- A value of zero (the default) tells PHP_CodeSniffer not to replace tabs with spaces - You can now change the default report format from "full" to something else -- Run: phpcs --config-set report_format [format] - Improved performance by optimising the way the scope map is created during tokenising - Added new Squiz DisallowInlineIfSniff to disallow the usage of inline IF statements - Fixed incorrect errors being thrown for nested switches in Squiz SwitchDeclarationSniff - PEAR FunctionCommentSniff no longer complains about missing comments for @throws tags - PEAR FunctionCommentSniff now throws error for missing exception class name for @throws tags - PHP_CodeSniffer_File::isReference() now correctly returns for functions that return references - Generic LineLengthSniff no longer warns about @version lines with CVS or SVN id tags - Generic LineLengthSniff no longer warns about @license lines with long URLs - Squiz FunctionCommentThrowTagSniff no longer complains about throwing variables - Squiz ComparisonOperatorUsageSniff no longer throws incorrect errors for inline IF statements - Squiz DisallowMultipleAssignmentsSniff no longer throws errors for assignments in inline IF statements - Fixed bug #12455 : CodeSniffer treats content inside heredoc as PHP code - Fixed bug #12471 : Checkstyle report is broken - Fixed bug #12476 : PHP4 destructors are reported as error - Fixed bug #12513 : Checkstyle XML messages need to be utf8_encode()d -- Thanks to Sebastian Bergmann for the patch. - Fixed bug #12517 : getNewlineAfter() and dos files 1.0.0RC2 1.0.0RC2 beta beta 2007-11-14 BSD License - Added a new Checkstyle report format -- Like the current XML format but modified to look like Checkstyle output -- Thanks to Manuel Pichler for helping get the format correct - You can now hide warnings by default -- Run: phpcs --config-set show_warnings 0 -- If warnings are hidden by default, use the new -w command line argument to override - Added new command line argument --config-delete to delete a config value and revert to the default - Improved overall performance by optimising tokenising and next/prev methods (feature request #12421) -- Thanks to Christian Weiske for the patch - Added FunctionCallSignatureSniff to Squiz standard - Added @subpackage support to file and class comment sniffs in PEAR standard (feature request #12382) -- Thanks to Carsten Wiedmann for the patch - An error is now displayed if you use a PHP version less than 5.1.0 (feature request #12380) -- Thanks to Carsten Wiedmann for the patch - phpcs now exits with status 2 if it receives invalid input (feature request #12380) -- This is distinct from status 1, which indicates errors or warnings were found - Added new Squiz LanguageConstructSpacingSniff to throw errors for additional whitespace after echo etc. - Removed Squiz ValidInterfaceNameSniff - PEAR FunctionCommentSniff no longer complains about unknown tags - Fixed incorrect errors about missing function comments in PEAR FunctionCommentSniff - Fixed incorrect function docblock detection in Squiz FunctionCommentSniff - Fixed incorrect errors for list() in Squiz DisallowMultipleAssignmentsSniff - Errors no longer thrown if control structure is followed by a CASE's BREAK in Squiz ControlStructureSpacingSniff - Fixed bug #12368 : Autoloader cannot be found due to include_path override -- Thanks to Richard Quadling for the patch - Fixed bug #12378 : equal sign alignments problem with while() 1.0.0RC1 1.0.0RC1 beta beta 2007-11-01 BSD License - Main phpcs script can now be run from a CVS checkout without installing the package - Added a new CSV report format -- Header row indicates what position each element is in -- Always use the header row to determine positions rather than assuming the format, as it may change - XML and CSV report formats now contain information about which column the error occurred at -- Useful if you want to highlight the token that caused the error in a custom application - Square bracket tokens now have bracket_opener and bracket_closer set - Added new Squiz SemicolonSpacingSniff to throw errors if whitespace is found before a semicolon - Added new Squiz ArrayBracketSpacingSniff to throw errors if whitespace is found around square brackets - Added new Squiz ObjectOperatorSpacingSniff to throw errors if whitespace is found around object operators - Added new Squiz DisallowMultipleAssignmentsSniff to throw errors if multiple assignments are on the same line - Added new Squiz ScopeKeywordSpacingSniff to throw errors if there is not a single space after a scope modifier - Added new Squiz ObjectInstantiationSniff to throw errors if new objects are not assigned to a variable - Added new Squiz FunctionDuplicateArgumentSniff to throw errors if argument is declared multiple times in a function - Added new Squiz FunctionOpeningBraceSpaceSniff to ensure there are no blank lines after a function open brace - Added new Squiz CommentedOutCodeSniff to warn about comments that looks like they are commented out code blocks - Added CyclomaticComplexitySniff to Squiz standard - Added NestingLevelSniff to Squiz standard - Squiz ForbiddenFunctionsSniff now recommends echo() instead of print() - Squiz ValidLogicalOperatorsSniff now recommends ^ instead of xor - Squiz SwitchDeclarationSniff now contains more checks -- A single space is required after the case keyword -- No space is allowed before the colon in a case or default statement -- All switch statements now require a default case -- Default case must contain a break statement -- Empty default case must contain a comment describing why the default is ignored -- Empty case statements are not allowed -- Case and default statements must not be followed by a blank line -- Break statements must be followed by a blank line or the closing brace -- There must be no blank line before a break statement - Squiz standard is now using the PEAR IncludingFileSniff - PEAR ClassCommentSniff no longer complains about unknown tags - PEAR FileCommentSniff no longer complains about unknown tags - PEAR FileCommentSniff now accepts multiple @copyright tags - Squiz BlockCommentSniff now checks that comment starts with a capital letter - Squiz InlineCommentSniff now has better checking to ensure comment starts with a capital letter - Squiz ClassCommentSniff now checks that short and long comments start with a capital letter - Squiz FunctionCommentSniff now checks that short, long and param comments start with a capital letter - Squiz VariableCommentSniff now checks that short and long comments start with a capital letter - Fixed error with multi-token array indexes in Squiz ArrayDeclarationSniff - Fixed error with checking shorthand IF statements without a semicolon in Squiz InlineIfDeclarationSniff - Fixed error where constants used as default values in function declarations were seen as type hints - Fixed bug #12316 : PEAR is no longer the default standard - Fixed bug #12321 : wrong detection of missing function docblock 0.9.0 0.9.0 beta beta 2007-09-24 BSD License - Added a config system for setting config data across phpcs runs - You can now change the default coding standard from PEAR to something else -- Run: phpcs --config-set default_standard [standard] - Added new Zend coding standard to check code against the Zend Framework standards -- The complete standard is not yet implemented -- Specify --standard=Zend to use -- Thanks to Johann-Peter Hartmann for the contribution of some sniffs -- Thanks to Holger Kral for the Code Analyzer sniff 0.8.0 0.8.0 beta beta 2007-08-08 BSD License - Added new XML report format; --report=xml (feature request #11535) -- Thanks to Brett Bieber for the patch - Added new command line argument --ignore to specify a list of files to skip (feature request #11556) - Added PHPCS and MySource coding standards into the core install - Scope map no longer gets confused by curly braces that act as string offsets - Removed CodeSniffer/SniffException.php as it is no longer used - Unit tests can now be run directly from a CVS checkout - Made private vars and functions protected in PHP_CodeSniffer class so this package can be overridden - Added new Metrics category to Generic coding standard -- Contains Cyclomatic Complexity and Nesting Level sniffs -- Thanks to Johann-Peter Hartmann for the contribution - Added new Generic DisallowTabIndentSniff to throw errors if tabs are used for indentation (feature request #11738) -- PEAR and Squiz standards use this new sniff to throw more specific indentation errors - Generic MultipleStatementAlignmentSniff has new private var to set a padding size limit (feature request #11555) - Generic MultipleStatementAlignmentSniff can now handle assignments that span multiple lines (feature request #11561) - Generic LineLengthSniff now has a max line length after which errors are thrown instead of warnings -- BC BREAK: Override the protected member var absoluteLineLimit and set it to zero in custom LineLength sniffs -- Thanks to Johann-Peter Hartmann for the contribution - Comment sniff errors about incorrect tag orders are now more descriptive (feature request #11693) - Fixed bug #11473 : Invalid CamelCaps name when numbers used in names 0.7.0 0.7.0 beta beta 2007-07-02 BSD License - BC BREAK: EOL character is now auto-detected and used instead of hard-coded \n -- Pattern sniffs must now specify "EOL" instead of "\n" or "\r\n" to use auto-detection -- Please use $phpcsFile->eolChar to check for newlines instead of hard-coding "\n" or "\r\n" -- Comment parser classes now require you to pass $phpcsFile as an additional argument - BC BREAK: Included and excluded sniffs now require .php extension -- Please update your coding standard classes and add ".php" to all sniff entries -- See CodeSniffer/Standards/PEAR/PEARCodingStandard.php for an example - Fixed error where including a directory of sniffs in a coding standard class did not work - Coding standard classes can now specify a list of sniffs to exclude as well as include (feature request #11056) - Two uppercase characters can now be placed side-by-side in class names in Squiz ValidClassNameSniff - SVN tags now allowed in PEAR file doc blocks (feature request #11038) -- Thanks to Torsten Roehr for the patch - Private methods in commenting sniffs and comment parser are now protected (feature request #11087) - Added Generic LineEndingsSniff to check the EOL character of a file - PEAR standard now only throws one error per file for incorrect line endings (eg. /r/n) - Command line arg -v now shows number of registered sniffs - Command line arg -vvv now shows list of registered sniffs - Squiz ControlStructureSpacingSniff no longer throws errors if the control structure is at the end of the script - Squiz FunctionCommentSniff now throws error for "return void" if function has return statement - Squiz FunctionCommentSniff now throws error for functions that return void but specify something else - Squiz ValidVariableNameSniff now allows multiple uppercase letters in a row - Squiz ForEachLoopDeclarationSniff now throws error for AS keyword not being lowercase - Squiz SwitchDeclarationSniff now throws errors for CASE/DEFAULT/BREAK keywords not being lowercase - Squiz ArrayDeclarationSniff now handles multi-token array values when checking alignment - Squiz standard now enforces a space after cast tokens - Generic MultipleStatementAlignmentSniff no longer gets confused by assignments inside FOR conditions - Generic MultipleStatementAlignmentSniff no longer gets confused by the use of list() - Added Generic SpaceAfterCastSniff to ensure there is a single space after a cast token - Added Generic NoSpaceAfterCastSniff to ensure there is no whitespace after a cast token - Added PEAR ClassDeclarationSniff to ensure the opening brace of a class is on the line after the keyword - Added Squiz ScopeClosingBraceSniff to ensure closing braces are aligned correctly - Added Squiz EvalSniff to discourage the use of eval() - Added Squiz LowercaseDeclarationSniff to ensure all declaration keywords are lowercase - Added Squiz LowercaseClassKeywordsSniff to ensure all class declaration keywords are lowercase - Added Squiz LowercaseFunctionKeywordsSniff to ensure all function declaration keywords are lowercase - Added Squiz LowercasePHPFunctionsSniff to ensure all calls to inbuilt PHP functions are lowercase - Added Squiz CastSpacingSniff to ensure cast statements dont contain whitespace - Errors no longer thrown when checking 0 length files with verbosity on - Fixed bug #11105 : getIncludedSniffs() not working anymore -- Thanks to Blair Robertson for the patch - Fixed bug #11120 : Uninitialized string offset in AbstractParser.php on line 200 0.6.0 0.6.0 beta beta 2007-05-15 BSD License - The number of errors and warnings found is now shown for each file while checking the file if verbosity is enabled - Now using PHP_EOL instead of hard-coded \n so output looks good on Windows (feature request #10761) - Thanks to Carsten Wiedmann for the patch. - phpcs now exits with status 0 (no errors) or 1 (errors found) (feature request #10348) - Added new -l command line argument to stop recursion into directories (feature request #10979) - Fixed variable name error causing incorrect error message in Squiz ValidVariableNameSniff - Fixed bug #10757 : Error in ControlSignatureSniff - Fixed bugs #10751, #10777 : Sniffer class paths handled incorrectly in Windows - Thanks to Carsten Wiedmann for the patch. - Fixed bug #10961 : Error "Last parameter comment requires a blank newline after it" thrown - Fixed bug #10983 : phpcs outputs notices when checking invalid PHP - Fixed bug #10980 : Incorrect warnings for equals sign 0.5.0 0.5.0 beta beta 2007-04-17 BSD License - BC BREAK: Coding standards now require a class to be added so PHP_CodeSniffer can get information from them - Please read the end user docs for info about the new class required for all coding standards - Coding standards can now include sniffs from other standards, or whole standards, without writing new sniff files - PHP_CodeSniffer_File::isReference() now correctly returns for references in function declarations - PHP_CodeSniffer_File::isReference() now returns false if you don't pass it a T_BITWISE_AND token - PHP_CodeSniffer_File now stores the absolute path to the file so sniffs can check file locations correctly - Fixed undefined index error in AbstractVariableSniff for variables inside an interface function definition - Added MemberVarSpacingSniff to Squiz standard to enforce one-line spacing between member vars - Add FunctionCommentThrowTagSniff to Squiz standard to check that @throws tags are correct - Fixed problems caused by references and type hints in Squiz FunctionDeclarationArgumentSpacingSniff - Fixed problems with errors not being thrown for some misaligned @param comments in Squiz FunctionCommentSniff - Fixed badly spaced comma error being thrown for "extends" class in Squiz ClassDeclarationSniff - Errors no longer thrown for class method names in Generic ForbiddenFunctionsSniff - Errors no longer thrown for type hints in front of references in Generic UpperCaseConstantNameSniff - Errors no longer thrown for correctly indented buffered lines in Squiz ScopeIndexSniff - Errors no longer thrown for user-defined functions named as forbidden functions in Generic ForbiddenFunctionsSniff - Errors no longer thrown on __autoload functions in PEAR ValidFunctionNameSniff - Errors now thrown for __autoload methods in PEAR ValidFunctionNameSniff - Errors now thrown if constructors or destructors have @return tags in Squiz FunctionCommentSniff - Errors now thrown if @throws tags dont start with a capital and end with a full stop in Squiz FunctionCommentSniff - Errors now thrown for invalid @var tag values in Squiz VariableCommentSniff - Errors now thrown for missing doc comment in Squiz VariableCommentSniff - Errors now thrown for unspaced operators in FOR loop declarations in Squiz OperatorSpacingSniff - Errors now thrown for using ob_get_clean/flush functions to end buffers in Squiz OutputBufferingIndentSniff - Errors now thrown for all missing member variable comments in Squiz VariableCommentSniff 0.4.0 0.4.0 beta beta 2007-02-19 BSD License - Standard name specified with --standard command line argument is no longer case sensitive - Long error and warning messages are now wrapped to 80 characters in the full error report (thanks Endre Czirbesz) - Shortened a lot of error and warning messages so they don't take up so much room - Squiz FunctionCommentSniff now checks that param comments start with a capital letter and end with a full stop - Squiz FunctionSpacingSniff now reports incorrect lines below function on closing brace, not function keyword - Squiz FileCommentSniff now checks that there are no blank lines between the open PHP tag and the comment - PHP_CodeSniffer_File::isReference() now returns correctly when checking refs on right side of => - Fixed incorrect error with switch closing brace in Squiz SwitchDeclarationSniff - Fixed missing error when multiple statements are not aligned correctly with object operators - Fixed incorrect errors for some PHP special variables in Squiz ValidVariableNameSniff - Fixed incorrect errors for arrays that only contain other arrays in Squiz ArrayDeclarationSniff - Fixed bug #9844 : throw new Exception(\n accidentally reported as error but it ain't 0.3.0 0.3.0 beta beta 2007-01-11 BSD License - Updated package.xml to version 2 - Specifying coding standard on command line is now optional, even if you have multiple standards installed - PHP_CodeSniffer uses the PEAR coding standard by default if no standard is specified - New command line option, --extensions, to specify a comma separated list of file extensions to check - Converted all unit tests to PHPUnit 3 format - Added new coding standard, Squiz, that can be used as an alternative to PEAR - also contains more examples of sniffs - some may be moved into the Generic coding standard if required - Added MultipleStatementAlignmentSniff to Generic standard - Added ScopeIndentSniff to Generic standard - Added ForbiddenFunctionsSniff to Generic standard - Added FileCommentSniff to PEAR standard - Added ClassCommentSniff to PEAR standard - Added FunctionCommentSniff to PEAR standard - Change MultipleStatementSniff to MultipleStatementAlignmentSniff in PEAR standard - Replaced Methods directory with Functions directory in Generic and PEAR standards - also renamed some of the sniffs in those directories - Updated file, class and method comments for all files - Fixed bug #9274 : nested_parenthesis element not set for open and close parenthesis tokens - Fixed bug #9411 : too few pattern characters cause incorrect error report 0.2.1 0.2.1 alpha alpha 2006-11-09 BSD License - Fixed bug #9274 : nested_parenthesis element not set for open and close parenthesis tokens 0.2.0 0.2.0 alpha alpha 2006-10-13 BSD License - Added a generic standards package that will contain generic sniffs to be used in specific coding standards - thanks to Frederic Poeydomenge for the idea - Changed PEAR standard to use generic sniffs where available - Added LowerCaseConstantSniff to Generic standard - Added UpperCaseConstantSniff to Generic standard - Added DisallowShortOpenTagSniff to Generic standard - Added LineLengthSniff to Generic standard - Added UpperCaseConstantNameSniff to Generic standard - Added OpeningMethodBraceBsdAllmanSniff to Generic standard (contrib by Frederic Poeydomenge) - Added OpeningMethodBraceKernighanRitchieSniff to Generic standard (contrib by Frederic Poeydomenge) - Added framework for core PHP_CodeSniffer unit tests - Added unit test for PHP_CodeSniffer:isCamelCaps method - ScopeClosingBraceSniff now checks indentation of BREAK statements - Added new command line arg (-vv) to show developer debug output - Fixed some coding standard errors - Fixed bug #8834 : Massive memory consumption - Fixed bug #8836 : path case issues in package.xml - Fixed bug #8843 : confusion on nested switch() - Fixed bug #8841 : comments taken as whitespace - Fixed bug #8884 : another problem with nested switch() statements 0.1.1 0.1.1 alpha alpha 2006-09-25 BSD License - Added unit tests for all PEAR sniffs - Exception class now extends from PEAR_Exception - Fixed summary report so files without errors but with warnings are not shown when warnings are hidden 0.1.0 0.1.0 alpha alpha 2006-09-19 BSD License - Reorganised package contents to conform to PEAR standards - Changed version numbering to conform to PEAR standards - Removed duplicate require_once() of Exception.php from CodeSniffer.php 0.0.5 0.0.5 alpha alpha 2006-09-18 BSD License - Fixed .bat file for situation where php.ini cannot be found so include_path is not set 0.0.4 0.0.4 alpha alpha 2006-08-28 BSD License - Added .bat file for easier running of PHP_CodeSniffer on Windows - Sniff that checks method names now works for PHP4 style code where there is no scope keyword - Sniff that checks method names now works for PHP4 style constructors - Sniff that checks method names no longer incorrectly reports error with magic methods - Sniff that checks method names now reports errors with non-magic methods prefixed with __ - Sniff that checks for constant names no longer incorrectly reports errors with heredoc strings - Sniff that checks for constant names no longer incorrectly reports errors with created objects - Sniff that checks indentation no longer incorrectly reports errors with heredoc strings - Sniff that checks indentation now correctly reports errors with improperly indented multi-line strings - Sniff that checks function declarations now checks for spaces before and after an equals sign for default values - Sniff that checks function declarations no longer incorrectly reports errors with multi-line declarations - Sniff that checks included code no longer incorrectly reports errors when return value is used conditionally - Sniff that checks opening brace of function no longer incorrectly reports errors with multi-line declarations - Sniff that checks spacing after commas in function calls no longer reports too many errors for some code - Sniff that checks control structure declarations now gives more descriptive error message 0.0.3 0.0.3 alpha alpha 2006-08-22 BSD License - Added sniff to check for invalid class and interface names - Added sniff to check for invalid function and method names - Added sniff to warn if line is greater than 85 characters - Added sniff to check that function calls are in the correct format - Fixed error where comments were not allowed on the same line as a control structure declaration - Added command line arg to print current version (--version) 0.0.2 0.0.2 alpha alpha 2006-07-25 BSD License - Removed the including of checked files to stop errors caused by parsing them - Removed the use of reflection so checked files do not have to be included - Memory usage has been greatly reduced - Much faster tokenising and checking times - Reworked the PEAR coding standard sniffs (much faster now) - Fix some bugs with the PEAR scope indentation standard - Better checking for installed coding standards - Can now accept multiple files and dirs on the command line - Added an option to list installed coding standards - Added an option to print a summary report (number of errors and warnings shown for each file) - Added an option to hide warnings from reports - Added an option to print verbose output (so you know what is going on) - Reordered command line args to put switches first (although order is not enforced) - Switches can now be specified together (eg. php -nv) as well as separately (phpcs -n -v) 0.0.1 0.0.1 alpha alpha 2006-07-19 BSD License Initial preview release. PHP_CodeSniffer-3.5.4/bin/phpcbf0000755000076500000240000000107413614652361016256 0ustar gsherwoodstaff#!/usr/bin/env php * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ if (is_file(__DIR__.'/../autoload.php') === true) { include_once __DIR__.'/../autoload.php'; } else { include_once 'PHP/CodeSniffer/autoload.php'; } $runner = new PHP_CodeSniffer\Runner(); $exitCode = $runner->runPHPCBF(); exit($exitCode); PHP_CodeSniffer-3.5.4/bin/phpcs0000755000076500000240000000105713614652361016132 0ustar gsherwoodstaff#!/usr/bin/env php * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ if (is_file(__DIR__.'/../autoload.php') === true) { include_once __DIR__.'/../autoload.php'; } else { include_once 'PHP/CodeSniffer/autoload.php'; } $runner = new PHP_CodeSniffer\Runner(); $exitCode = $runner->runPHPCS(); exit($exitCode); PHP_CodeSniffer-3.5.4/bin/phpcs.bat0000755000076500000240000000063213614652361016675 0ustar gsherwoodstaff@echo off REM PHP_CodeSniffer detects violations of a defined coding standard. REM REM @author Greg Sherwood REM @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) REM @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence if "%PHP_PEAR_PHP_BIN%" neq "" ( set PHPBIN=%PHP_PEAR_PHP_BIN% ) else set PHPBIN=php "%PHPBIN%" "%~dp0\phpcs" %* PHP_CodeSniffer-3.5.4/bin/phpcbf.bat0000644000076500000240000000064713614652361017025 0ustar gsherwoodstaff@echo off REM PHP Code Beautifier and Fixer fixes violations of a defined coding standard. REM REM @author Greg Sherwood REM @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) REM @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence if "%PHP_PEAR_PHP_BIN%" neq "" ( set PHPBIN=%PHP_PEAR_PHP_BIN% ) else set PHPBIN=php "%PHPBIN%" "%~dp0\phpcbf" %* PHP_CodeSniffer-3.5.4/tests/Core/File/FindEndOfStatementTest.inc0000644000076500000240000000130213614652361024235 0ustar gsherwoodstaff fn() => return 1, 'b' => fn() => return 1, ]; /* testStaticArrowFunction */ static fn ($a) => $a; /* testArrowFunctionReturnValue */ fn(): array => [a($a, $b)]; return 0; PHP_CodeSniffer-3.5.4/tests/Core/File/FindEndOfStatementTest.php0000644000076500000240000001515013614652361024261 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests\Core\File; use PHP_CodeSniffer\Tests\Core\AbstractMethodUnitTest; class FindEndOfStatementTest extends AbstractMethodUnitTest { /** * Test a simple assignment. * * @return void */ public function testSimpleAssignment() { $start = (self::$phpcsFile->findNext(T_COMMENT, 0, null, false, '/* testSimpleAssignment */') + 2); $found = self::$phpcsFile->findEndOfStatement($start); $tokens = self::$phpcsFile->getTokens(); $this->assertSame($tokens[($start + 5)], $tokens[$found]); }//end testSimpleAssignment() /** * Test a direct call to a control structure. * * @return void */ public function testControlStructure() { $start = (self::$phpcsFile->findNext(T_COMMENT, 0, null, false, '/* testControlStructure */') + 2); $found = self::$phpcsFile->findEndOfStatement($start); $tokens = self::$phpcsFile->getTokens(); $this->assertSame($tokens[($start + 6)], $tokens[$found]); }//end testControlStructure() /** * Test the assignment of a closure. * * @return void */ public function testClosureAssignment() { $start = (self::$phpcsFile->findNext(T_COMMENT, 0, null, false, '/* testClosureAssignment */') + 2); $found = self::$phpcsFile->findEndOfStatement($start); $tokens = self::$phpcsFile->getTokens(); $this->assertSame($tokens[($start + 13)], $tokens[$found]); }//end testClosureAssignment() /** * Test using a heredoc in a function argument. * * @return void */ public function testHeredocFunctionArg() { // Find the end of the function. $start = (self::$phpcsFile->findNext(T_COMMENT, 0, null, false, '/* testHeredocFunctionArg */') + 2); $found = self::$phpcsFile->findEndOfStatement($start); $tokens = self::$phpcsFile->getTokens(); $this->assertSame($tokens[($start + 10)], $tokens[$found]); // Find the end of the heredoc. $start += 2; $found = self::$phpcsFile->findEndOfStatement($start); $tokens = self::$phpcsFile->getTokens(); $this->assertSame($tokens[($start + 4)], $tokens[$found]); // Find the end of the last arg. $start = ($found + 2); $found = self::$phpcsFile->findEndOfStatement($start); $tokens = self::$phpcsFile->getTokens(); $this->assertSame($tokens[$start], $tokens[$found]); }//end testHeredocFunctionArg() /** * Test parts of a switch statement. * * @return void */ public function testSwitch() { // Find the end of the switch. $start = (self::$phpcsFile->findNext(T_COMMENT, 0, null, false, '/* testSwitch */') + 2); $found = self::$phpcsFile->findEndOfStatement($start); $tokens = self::$phpcsFile->getTokens(); $this->assertSame($tokens[($start + 28)], $tokens[$found]); // Find the end of the case. $start += 9; $found = self::$phpcsFile->findEndOfStatement($start); $tokens = self::$phpcsFile->getTokens(); $this->assertSame($tokens[($start + 8)], $tokens[$found]); // Find the end of default case. $start += 11; $found = self::$phpcsFile->findEndOfStatement($start); $tokens = self::$phpcsFile->getTokens(); $this->assertSame($tokens[($start + 6)], $tokens[$found]); }//end testSwitch() /** * Test statements that are array values. * * @return void */ public function testStatementAsArrayValue() { // Test short array syntax. $start = (self::$phpcsFile->findNext(T_COMMENT, 0, null, false, '/* testStatementAsArrayValue */') + 7); $found = self::$phpcsFile->findEndOfStatement($start); $tokens = self::$phpcsFile->getTokens(); $this->assertSame($tokens[($start + 2)], $tokens[$found]); // Test long array syntax. $start += 12; $found = self::$phpcsFile->findEndOfStatement($start); $tokens = self::$phpcsFile->getTokens(); $this->assertSame($tokens[($start + 2)], $tokens[$found]); // Test same statement outside of array. $start += 10; $found = self::$phpcsFile->findEndOfStatement($start); $tokens = self::$phpcsFile->getTokens(); $this->assertSame($tokens[($start + 3)], $tokens[$found]); }//end testStatementAsArrayValue() /** * Test a use group. * * @return void */ public function testUseGroup() { $start = (self::$phpcsFile->findNext(T_COMMENT, 0, null, false, '/* testUseGroup */') + 2); $found = self::$phpcsFile->findEndOfStatement($start); $tokens = self::$phpcsFile->getTokens(); $this->assertSame($tokens[($start + 23)], $tokens[$found]); }//end testUseGroup() /** * Test a use group. * * @return void */ public function testArrowFunctionArrayValue() { $start = (self::$phpcsFile->findNext(T_COMMENT, 0, null, false, '/* testArrowFunctionArrayValue */') + 7); $found = self::$phpcsFile->findEndOfStatement($start); $tokens = self::$phpcsFile->getTokens(); $this->assertSame($tokens[($start + 9)], $tokens[$found]); }//end testArrowFunctionArrayValue() /** * Test static arrow function. * * @return void */ public function testStaticArrowFunction() { $static = (self::$phpcsFile->findNext(T_COMMENT, 0, null, false, '/* testStaticArrowFunction */') + 2); $fn = self::$phpcsFile->findNext(T_FN, ($static + 1)); $endOfStatementStatic = self::$phpcsFile->findEndOfStatement($static); $endOfStatementFn = self::$phpcsFile->findEndOfStatement($fn); $this->assertSame($endOfStatementFn, $endOfStatementStatic); }//end testStaticArrowFunction() /** * Test arrow function with return value. * * @return void */ public function testArrowFunctionReturnValue() { $start = (self::$phpcsFile->findNext(T_COMMENT, 0, null, false, '/* testArrowFunctionReturnValue */') + 2); $found = self::$phpcsFile->findEndOfStatement($start); $tokens = self::$phpcsFile->getTokens(); $this->assertSame($tokens[($start + 18)], $tokens[$found]); }//end testArrowFunctionReturnValue() }//end class PHP_CodeSniffer-3.5.4/tests/Core/File/FindExtendedClassNameTest.inc0000644000076500000240000000214613614652361024713 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests\Core\File; use PHP_CodeSniffer\Tests\Core\AbstractMethodUnitTest; class FindExtendedClassNameTest extends AbstractMethodUnitTest { /** * Test retrieving the name of the class being extended by another class * (or interface). * * @param string $identifier Comment which precedes the test case. * @param bool $expected Expected function output. * * @dataProvider dataExtendedClass * * @return void */ public function testFindExtendedClassName($identifier, $expected) { $OOToken = $this->getTargetToken($identifier, [T_CLASS, T_ANON_CLASS, T_INTERFACE]); $result = self::$phpcsFile->findExtendedClassName($OOToken); $this->assertSame($expected, $result); }//end testFindExtendedClassName() /** * Data provider for the FindExtendedClassName test. * * @see testFindExtendedClassName() * * @return array */ public function dataExtendedClass() { return [ [ '/* testExtendedClass */', 'testFECNClass', ], [ '/* testNamespacedClass */', '\PHP_CodeSniffer\Tests\Core\File\testFECNClass', ], [ '/* testNonExtendedClass */', false, ], [ '/* testInterface */', false, ], [ '/* testInterfaceThatExtendsInterface */', 'testFECNInterface', ], [ '/* testInterfaceThatExtendsFQCNInterface */', '\PHP_CodeSniffer\Tests\Core\File\testFECNInterface', ], [ '/* testNestedExtendedClass */', false, ], [ '/* testNestedExtendedAnonClass */', 'testFECNAnonClass', ], [ '/* testClassThatExtendsAndImplements */', 'testFECNClass', ], [ '/* testClassThatImplementsAndExtends */', 'testFECNClass', ], ]; }//end dataExtendedClass() }//end class PHP_CodeSniffer-3.5.4/tests/Core/File/FindImplementedInterfaceNamesTest.inc0000644000076500000240000000151213614652361026430 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests\Core\File; use PHP_CodeSniffer\Tests\Core\AbstractMethodUnitTest; class FindImplementedInterfaceNamesTest extends AbstractMethodUnitTest { /** * Test retrieving the name(s) of the interfaces being implemented by a class. * * @param string $identifier Comment which precedes the test case. * @param bool $expected Expected function output. * * @dataProvider dataImplementedInterface * * @return void */ public function testFindImplementedInterfaceNames($identifier, $expected) { $OOToken = $this->getTargetToken($identifier, [T_CLASS, T_ANON_CLASS, T_INTERFACE]); $result = self::$phpcsFile->findImplementedInterfaceNames($OOToken); $this->assertSame($expected, $result); }//end testFindImplementedInterfaceNames() /** * Data provider for the FindImplementedInterfaceNames test. * * @see testFindImplementedInterfaceNames() * * @return array */ public function dataImplementedInterface() { return [ [ '/* testImplementedClass */', ['testFIINInterface'], ], [ '/* testMultiImplementedClass */', [ 'testFIINInterface', 'testFIINInterface2', ], ], [ '/* testNamespacedClass */', ['\PHP_CodeSniffer\Tests\Core\File\testFIINInterface'], ], [ '/* testNonImplementedClass */', false, ], [ '/* testInterface */', false, ], [ '/* testClassThatExtendsAndImplements */', [ 'InterfaceA', '\NameSpaced\Cat\InterfaceB', ], ], [ '/* testClassThatImplementsAndExtends */', [ '\InterfaceA', 'InterfaceB', ], ], ]; }//end dataImplementedInterface() }//end class PHP_CodeSniffer-3.5.4/tests/Core/File/GetMemberPropertiesTest.inc0000644000076500000240000000723113614652361024507 0ustar gsherwoodstaff 'a', 'b' => 'b' ), /* testGroupPrivate 3 */ $varQ = 'string', /* testGroupPrivate 4 */ $varR = 123, /* testGroupPrivate 5 */ $varS = ONE / self::THREE, /* testGroupPrivate 6 */ $varT = [ 'a' => 'a', 'b' => 'b' ], /* testGroupPrivate 7 */ $varU = __DIR__ . "/base"; /* testMethodParam */ public function methodName($param) { /* testImportedGlobal */ global $importedGlobal = true; /* testLocalVariable */ $localVariable = true; } /* testPropertyAfterMethod */ private static $varV = true; /* testMessyNullableType */ public /* comment */ ? //comment array $foo = []; /* testNamespaceType */ public \MyNamespace\MyClass $foo; /* testNullableNamespaceType 1 */ private ?ClassName $nullableClassType; /* testNullableNamespaceType 2 */ protected ?Folder\ClassName $nullableClassType2; /* testMultilineNamespaceType */ public \MyNamespace /** comment *\/ comment */ \MyClass /* comment */ \Foo $foo; } interface Base { /* testInterfaceProperty */ protected $anonymous; } /* testGlobalVariable */ $globalVariable = true; /* testNotAVariable */ return; $a = ( $foo == $bar ? new stdClass() : new class() { /* testNestedProperty 1 */ public $var = true; /* testNestedMethodParam 1 */ public function something($var = false) {} } ); function_call( 'param', new class { /* testNestedProperty 2 */ public $year = 2017; /* testNestedMethodParam 2 */ public function __construct( $open, $post_id ) {} }, 10, 2 ); PHP_CodeSniffer-3.5.4/tests/Core/File/GetMemberPropertiesTest.php0000644000076500000240000004227113614652361024530 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests\Core\File; use PHP_CodeSniffer\Tests\Core\AbstractMethodUnitTest; class GetMemberPropertiesTest extends AbstractMethodUnitTest { /** * Test the getMemberProperties() method. * * @param string $identifier Comment which precedes the test case. * @param bool $expected Expected function output. * * @dataProvider dataGetMemberProperties * * @return void */ public function testGetMemberProperties($identifier, $expected) { $variable = $this->getTargetToken($identifier, T_VARIABLE); $result = self::$phpcsFile->getMemberProperties($variable); $this->assertArraySubset($expected, $result, true); }//end testGetMemberProperties() /** * Data provider for the GetMemberProperties test. * * @see testGetMemberProperties() * * @return array */ public function dataGetMemberProperties() { return [ [ '/* testVar */', [ 'scope' => 'public', 'scope_specified' => false, 'is_static' => false, 'type' => '', 'nullable_type' => false, ], ], [ '/* testVarType */', [ 'scope' => 'public', 'scope_specified' => false, 'is_static' => false, 'type' => '?int', 'nullable_type' => true, ], ], [ '/* testPublic */', [ 'scope' => 'public', 'scope_specified' => true, 'is_static' => false, 'type' => '', 'nullable_type' => false, ], ], [ '/* testPublicType */', [ 'scope' => 'public', 'scope_specified' => true, 'is_static' => false, 'type' => 'string', 'nullable_type' => false, ], ], [ '/* testProtected */', [ 'scope' => 'protected', 'scope_specified' => true, 'is_static' => false, 'type' => '', 'nullable_type' => false, ], ], [ '/* testProtectedType */', [ 'scope' => 'protected', 'scope_specified' => true, 'is_static' => false, 'type' => 'bool', 'nullable_type' => false, ], ], [ '/* testPrivate */', [ 'scope' => 'private', 'scope_specified' => true, 'is_static' => false, 'type' => '', 'nullable_type' => false, ], ], [ '/* testPrivateType */', [ 'scope' => 'private', 'scope_specified' => true, 'is_static' => false, 'type' => 'array', 'nullable_type' => false, ], ], [ '/* testStatic */', [ 'scope' => 'public', 'scope_specified' => false, 'is_static' => true, 'type' => '', 'nullable_type' => false, ], ], [ '/* testStaticType */', [ 'scope' => 'public', 'scope_specified' => false, 'is_static' => true, 'type' => '?string', 'nullable_type' => true, ], ], [ '/* testStaticVar */', [ 'scope' => 'public', 'scope_specified' => false, 'is_static' => true, 'type' => '', 'nullable_type' => false, ], ], [ '/* testVarStatic */', [ 'scope' => 'public', 'scope_specified' => false, 'is_static' => true, 'type' => '', 'nullable_type' => false, ], ], [ '/* testPublicStatic */', [ 'scope' => 'public', 'scope_specified' => true, 'is_static' => true, 'type' => '', 'nullable_type' => false, ], ], [ '/* testProtectedStatic */', [ 'scope' => 'protected', 'scope_specified' => true, 'is_static' => true, 'type' => '', 'nullable_type' => false, ], ], [ '/* testPrivateStatic */', [ 'scope' => 'private', 'scope_specified' => true, 'is_static' => true, 'type' => '', 'nullable_type' => false, ], ], [ '/* testPublicStaticWithDocblock */', [ 'scope' => 'public', 'scope_specified' => true, 'is_static' => true, 'type' => '', 'nullable_type' => false, ], ], [ '/* testProtectedStaticWithDocblock */', [ 'scope' => 'protected', 'scope_specified' => true, 'is_static' => true, 'type' => '', 'nullable_type' => false, ], ], [ '/* testPrivateStaticWithDocblock */', [ 'scope' => 'private', 'scope_specified' => true, 'is_static' => true, 'type' => '', 'nullable_type' => false, ], ], [ '/* testGroupType 1 */', [ 'scope' => 'public', 'scope_specified' => true, 'is_static' => false, 'type' => 'float', 'nullable_type' => false, ], ], [ '/* testGroupType 2 */', [ 'scope' => 'public', 'scope_specified' => true, 'is_static' => false, 'type' => 'float', 'nullable_type' => false, ], ], [ '/* testGroupNullableType 1 */', [ 'scope' => 'public', 'scope_specified' => true, 'is_static' => true, 'type' => '?string', 'nullable_type' => true, ], ], [ '/* testGroupNullableType 2 */', [ 'scope' => 'public', 'scope_specified' => true, 'is_static' => true, 'type' => '?string', 'nullable_type' => true, ], ], [ '/* testNoPrefix */', [ 'scope' => 'public', 'scope_specified' => false, 'is_static' => false, 'type' => '', 'nullable_type' => false, ], ], [ '/* testGroupProtectedStatic 1 */', [ 'scope' => 'protected', 'scope_specified' => true, 'is_static' => true, 'type' => '', 'nullable_type' => false, ], ], [ '/* testGroupProtectedStatic 2 */', [ 'scope' => 'protected', 'scope_specified' => true, 'is_static' => true, 'type' => '', 'nullable_type' => false, ], ], [ '/* testGroupProtectedStatic 3 */', [ 'scope' => 'protected', 'scope_specified' => true, 'is_static' => true, 'type' => '', 'nullable_type' => false, ], ], [ '/* testGroupPrivate 1 */', [ 'scope' => 'private', 'scope_specified' => true, 'is_static' => false, 'type' => '', 'nullable_type' => false, ], ], [ '/* testGroupPrivate 2 */', [ 'scope' => 'private', 'scope_specified' => true, 'is_static' => false, 'type' => '', 'nullable_type' => false, ], ], [ '/* testGroupPrivate 3 */', [ 'scope' => 'private', 'scope_specified' => true, 'is_static' => false, 'type' => '', 'nullable_type' => false, ], ], [ '/* testGroupPrivate 4 */', [ 'scope' => 'private', 'scope_specified' => true, 'is_static' => false, 'type' => '', 'nullable_type' => false, ], ], [ '/* testGroupPrivate 5 */', [ 'scope' => 'private', 'scope_specified' => true, 'is_static' => false, 'type' => '', 'nullable_type' => false, ], ], [ '/* testGroupPrivate 6 */', [ 'scope' => 'private', 'scope_specified' => true, 'is_static' => false, 'type' => '', 'nullable_type' => false, ], ], [ '/* testGroupPrivate 7 */', [ 'scope' => 'private', 'scope_specified' => true, 'is_static' => false, 'type' => '', 'nullable_type' => false, ], ], [ '/* testMessyNullableType */', [ 'scope' => 'public', 'scope_specified' => true, 'is_static' => false, 'type' => '?array', 'nullable_type' => true, ], ], [ '/* testNamespaceType */', [ 'scope' => 'public', 'scope_specified' => true, 'is_static' => false, 'type' => '\MyNamespace\MyClass', 'nullable_type' => false, ], ], [ '/* testNullableNamespaceType 1 */', [ 'scope' => 'private', 'scope_specified' => true, 'is_static' => false, 'type' => '?ClassName', 'nullable_type' => true, ], ], [ '/* testNullableNamespaceType 2 */', [ 'scope' => 'protected', 'scope_specified' => true, 'is_static' => false, 'type' => '?Folder\ClassName', 'nullable_type' => true, ], ], [ '/* testMultilineNamespaceType */', [ 'scope' => 'public', 'scope_specified' => true, 'is_static' => false, 'type' => '\MyNamespace\MyClass\Foo', 'nullable_type' => false, ], ], [ '/* testPropertyAfterMethod */', [ 'scope' => 'private', 'scope_specified' => true, 'is_static' => true, 'type' => '', 'nullable_type' => false, ], ], [ '/* testInterfaceProperty */', [], ], [ '/* testNestedProperty 1 */', [ 'scope' => 'public', 'scope_specified' => true, 'is_static' => false, 'type' => '', 'nullable_type' => false, ], ], [ '/* testNestedProperty 2 */', [ 'scope' => 'public', 'scope_specified' => true, 'is_static' => false, 'type' => '', 'nullable_type' => false, ], ], ]; }//end dataGetMemberProperties() /** * Test receiving an expected exception when a non property is passed. * * @param string $identifier Comment which precedes the test case. * * @expectedException PHP_CodeSniffer\Exceptions\RuntimeException * @expectedExceptionMessage $stackPtr is not a class member var * * @dataProvider dataNotClassProperty * * @return void */ public function testNotClassPropertyException($identifier) { $variable = $this->getTargetToken($identifier, T_VARIABLE); $result = self::$phpcsFile->getMemberProperties($variable); }//end testNotClassPropertyException() /** * Data provider for the NotClassPropertyException test. * * @see testNotClassPropertyException() * * @return array */ public function dataNotClassProperty() { return [ ['/* testMethodParam */'], ['/* testImportedGlobal */'], ['/* testLocalVariable */'], ['/* testGlobalVariable */'], ['/* testNestedMethodParam 1 */'], ['/* testNestedMethodParam 2 */'], ]; }//end dataNotClassProperty() /** * Test receiving an expected exception when a non variable is passed. * * @expectedException PHP_CodeSniffer\Exceptions\RuntimeException * @expectedExceptionMessage $stackPtr must be of type T_VARIABLE * * @return void */ public function testNotAVariableException() { $next = $this->getTargetToken('/* testNotAVariable */', T_RETURN); $result = self::$phpcsFile->getMemberProperties($next); }//end testNotAVariableException() }//end class PHP_CodeSniffer-3.5.4/tests/Core/File/GetMethodParametersTest.inc0000644000076500000240000000126413614652361024467 0ustar gsherwoodstaff $b; PHP_CodeSniffer-3.5.4/tests/Core/File/GetMethodParametersTest.php0000644000076500000240000001771713614652361024517 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests\Core\File; use PHP_CodeSniffer\Tests\Core\AbstractMethodUnitTest; class GetMethodParametersTest extends AbstractMethodUnitTest { /** * Verify pass-by-reference parsing. * * @return void */ public function testPassByReference() { $expected = []; $expected[0] = [ 'name' => '$var', 'content' => '&$var', 'pass_by_reference' => true, 'variable_length' => false, 'type_hint' => '', 'nullable_type' => false, ]; $this->getMethodParametersTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testPassByReference() /** * Verify array hint parsing. * * @return void */ public function testArrayHint() { $expected = []; $expected[0] = [ 'name' => '$var', 'content' => 'array $var', 'pass_by_reference' => false, 'variable_length' => false, 'type_hint' => 'array', 'nullable_type' => false, ]; $this->getMethodParametersTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testArrayHint() /** * Verify type hint parsing. * * @return void */ public function testTypeHint() { $expected = []; $expected[0] = [ 'name' => '$var1', 'content' => 'foo $var1', 'pass_by_reference' => false, 'variable_length' => false, 'type_hint' => 'foo', 'nullable_type' => false, ]; $expected[1] = [ 'name' => '$var2', 'content' => 'bar $var2', 'pass_by_reference' => false, 'variable_length' => false, 'type_hint' => 'bar', 'nullable_type' => false, ]; $this->getMethodParametersTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testTypeHint() /** * Verify self type hint parsing. * * @return void */ public function testSelfTypeHint() { $expected = []; $expected[0] = [ 'name' => '$var', 'content' => 'self $var', 'pass_by_reference' => false, 'variable_length' => false, 'type_hint' => 'self', 'nullable_type' => false, ]; $this->getMethodParametersTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testSelfTypeHint() /** * Verify nullable type hint parsing. * * @return void */ public function testNullableTypeHint() { $expected = []; $expected[0] = [ 'name' => '$var1', 'content' => '?int $var1', 'pass_by_reference' => false, 'variable_length' => false, 'type_hint' => '?int', 'nullable_type' => true, ]; $expected[1] = [ 'name' => '$var2', 'content' => '?\bar $var2', 'pass_by_reference' => false, 'variable_length' => false, 'type_hint' => '?\bar', 'nullable_type' => true, ]; $this->getMethodParametersTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testNullableTypeHint() /** * Verify variable. * * @return void */ public function testVariable() { $expected = []; $expected[0] = [ 'name' => '$var', 'content' => '$var', 'pass_by_reference' => false, 'variable_length' => false, 'type_hint' => '', 'nullable_type' => false, ]; $this->getMethodParametersTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testVariable() /** * Verify default value parsing with a single function param. * * @return void */ public function testSingleDefaultValue() { $expected = []; $expected[0] = [ 'name' => '$var1', 'content' => '$var1=self::CONSTANT', 'default' => 'self::CONSTANT', 'pass_by_reference' => false, 'variable_length' => false, 'type_hint' => '', 'nullable_type' => false, ]; $this->getMethodParametersTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testSingleDefaultValue() /** * Verify default value parsing. * * @return void */ public function testDefaultValues() { $expected = []; $expected[0] = [ 'name' => '$var1', 'content' => '$var1=1', 'default' => '1', 'pass_by_reference' => false, 'variable_length' => false, 'type_hint' => '', 'nullable_type' => false, ]; $expected[1] = [ 'name' => '$var2', 'content' => "\$var2='value'", 'default' => "'value'", 'pass_by_reference' => false, 'variable_length' => false, 'type_hint' => '', 'nullable_type' => false, ]; $this->getMethodParametersTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testDefaultValues() /** * Verify "bitwise and" in default value !== pass-by-reference. * * @return void */ public function testBitwiseAndConstantExpressionDefaultValue() { $expected = []; $expected[0] = [ 'name' => '$a', 'content' => '$a = 10 & 20', 'default' => '10 & 20', 'pass_by_reference' => false, 'variable_length' => false, 'type_hint' => '', 'nullable_type' => false, ]; $this->getMethodParametersTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testBitwiseAndConstantExpressionDefaultValue() /** * Verify that arrow functions are supported. * * @return void */ public function testArrowFunction() { $expected = []; $expected[0] = [ 'name' => '$a', 'content' => 'int $a', 'pass_by_reference' => false, 'variable_length' => false, 'type_hint' => 'int', 'nullable_type' => false, ]; $expected[1] = [ 'name' => '$b', 'content' => '...$b', 'pass_by_reference' => false, 'variable_length' => true, 'type_hint' => '', 'nullable_type' => false, ]; $this->getMethodParametersTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testArrowFunction() /** * Test helper. * * @param string $commentString The comment which preceeds the test. * @param array $expected The expected function output. * * @return void */ private function getMethodParametersTestHelper($commentString, $expected) { $function = $this->getTargetToken($commentString, [T_FUNCTION, T_FN]); $found = self::$phpcsFile->getMethodParameters($function); $this->assertArraySubset($expected, $found, true); }//end getMethodParametersTestHelper() }//end class PHP_CodeSniffer-3.5.4/tests/Core/File/GetMethodPropertiesTest.inc0000644000076500000240000000276713614652361024531 0ustar gsherwoodstaff $number + 1, $numbers ); PHP_CodeSniffer-3.5.4/tests/Core/File/GetMethodPropertiesTest.php0000644000076500000240000002637413614652361024547 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests\Core\File; use PHP_CodeSniffer\Tests\Core\AbstractMethodUnitTest; class GetMethodPropertiesTest extends AbstractMethodUnitTest { /** * Test a basic function. * * @return void */ public function testBasicFunction() { $expected = [ 'scope' => 'public', 'scope_specified' => false, 'return_type' => '', 'nullable_return_type' => false, 'is_abstract' => false, 'is_final' => false, 'is_static' => false, 'has_body' => true, ]; $this->getMethodPropertiesTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testBasicFunction() /** * Test a function with a return type. * * @return void */ public function testReturnFunction() { $expected = [ 'scope' => 'public', 'scope_specified' => false, 'return_type' => 'array', 'nullable_return_type' => false, 'is_abstract' => false, 'is_final' => false, 'is_static' => false, 'has_body' => true, ]; $this->getMethodPropertiesTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testReturnFunction() /** * Test a closure used as a function argument. * * @return void */ public function testNestedClosure() { $expected = [ 'scope' => 'public', 'scope_specified' => false, 'return_type' => 'int', 'nullable_return_type' => false, 'is_abstract' => false, 'is_final' => false, 'is_static' => false, 'has_body' => true, ]; $this->getMethodPropertiesTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testNestedClosure() /** * Test a basic method. * * @return void */ public function testBasicMethod() { $expected = [ 'scope' => 'public', 'scope_specified' => false, 'return_type' => '', 'nullable_return_type' => false, 'is_abstract' => false, 'is_final' => false, 'is_static' => false, 'has_body' => true, ]; $this->getMethodPropertiesTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testBasicMethod() /** * Test a private static method. * * @return void */ public function testPrivateStaticMethod() { $expected = [ 'scope' => 'private', 'scope_specified' => true, 'return_type' => '', 'nullable_return_type' => false, 'is_abstract' => false, 'is_final' => false, 'is_static' => true, 'has_body' => true, ]; $this->getMethodPropertiesTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testPrivateStaticMethod() /** * Test a basic final method. * * @return void */ public function testFinalMethod() { $expected = [ 'scope' => 'public', 'scope_specified' => true, 'return_type' => '', 'nullable_return_type' => false, 'is_abstract' => false, 'is_final' => true, 'is_static' => false, 'has_body' => true, ]; $this->getMethodPropertiesTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testFinalMethod() /** * Test a protected method with a return type. * * @return void */ public function testProtectedReturnMethod() { $expected = [ 'scope' => 'protected', 'scope_specified' => true, 'return_type' => 'int', 'nullable_return_type' => false, 'is_abstract' => false, 'is_final' => false, 'is_static' => false, 'has_body' => true, ]; $this->getMethodPropertiesTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testProtectedReturnMethod() /** * Test a public method with a return type. * * @return void */ public function testPublicReturnMethod() { $expected = [ 'scope' => 'public', 'scope_specified' => true, 'return_type' => 'array', 'nullable_return_type' => false, 'is_abstract' => false, 'is_final' => false, 'is_static' => false, 'has_body' => true, ]; $this->getMethodPropertiesTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testPublicReturnMethod() /** * Test a public method with a nullable return type. * * @return void */ public function testNullableReturnMethod() { $expected = [ 'scope' => 'public', 'scope_specified' => true, 'return_type' => '?array', 'nullable_return_type' => true, 'is_abstract' => false, 'is_final' => false, 'is_static' => false, 'has_body' => true, ]; $this->getMethodPropertiesTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testNullableReturnMethod() /** * Test a public method with a nullable return type. * * @return void */ public function testMessyNullableReturnMethod() { $expected = [ 'scope' => 'public', 'scope_specified' => true, 'return_type' => '?array', 'nullable_return_type' => true, 'is_abstract' => false, 'is_final' => false, 'is_static' => false, 'has_body' => true, ]; $this->getMethodPropertiesTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testMessyNullableReturnMethod() /** * Test a method with a namespaced return type. * * @return void */ public function testReturnNamespace() { $expected = [ 'scope' => 'public', 'scope_specified' => false, 'return_type' => '\MyNamespace\MyClass', 'nullable_return_type' => false, 'is_abstract' => false, 'is_final' => false, 'is_static' => false, 'has_body' => true, ]; $this->getMethodPropertiesTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testReturnNamespace() /** * Test a method with a messy namespaces return type. * * @return void */ public function testReturnMultilineNamespace() { $expected = [ 'scope' => 'public', 'scope_specified' => false, 'return_type' => '\MyNamespace\MyClass\Foo', 'nullable_return_type' => false, 'is_abstract' => false, 'is_final' => false, 'is_static' => false, 'has_body' => true, ]; $this->getMethodPropertiesTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testReturnMultilineNamespace() /** * Test a basic abstract method. * * @return void */ public function testAbstractMethod() { $expected = [ 'scope' => 'public', 'scope_specified' => false, 'return_type' => '', 'nullable_return_type' => false, 'is_abstract' => true, 'is_final' => false, 'is_static' => false, 'has_body' => false, ]; $this->getMethodPropertiesTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testAbstractMethod() /** * Test an abstract method with a return type. * * @return void */ public function testAbstractReturnMethod() { $expected = [ 'scope' => 'protected', 'scope_specified' => true, 'return_type' => 'bool', 'nullable_return_type' => false, 'is_abstract' => true, 'is_final' => false, 'is_static' => false, 'has_body' => false, ]; $this->getMethodPropertiesTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testAbstractReturnMethod() /** * Test a basic interface method. * * @return void */ public function testInterfaceMethod() { $expected = [ 'scope' => 'public', 'scope_specified' => false, 'return_type' => '', 'nullable_return_type' => false, 'is_abstract' => false, 'is_final' => false, 'is_static' => false, 'has_body' => false, ]; $this->getMethodPropertiesTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testInterfaceMethod() /** * Test a static arrow function. * * @return void */ public function testArrowFunction() { $expected = [ 'scope' => 'public', 'scope_specified' => false, 'return_type' => 'int', 'nullable_return_type' => false, 'is_abstract' => false, 'is_final' => false, 'is_static' => true, 'has_body' => true, ]; $this->getMethodPropertiesTestHelper('/* '.__FUNCTION__.' */', $expected); }//end testArrowFunction() /** * Test helper. * * @param string $commentString The comment which preceeds the test. * @param array $expected The expected function output. * * @return void */ private function getMethodPropertiesTestHelper($commentString, $expected) { $function = $this->getTargetToken($commentString, [T_FUNCTION, T_CLOSURE, T_FN]); $found = self::$phpcsFile->getMethodProperties($function); $this->assertArraySubset($expected, $found, true); }//end getMethodPropertiesTestHelper() }//end class PHP_CodeSniffer-3.5.4/tests/Core/File/IsReferenceTest.inc0000644000076500000240000000635513614652361022763 0ustar gsherwoodstaff $first, 'b' => $something & $somethingElse ]; /* testBitwiseAndF */ $a = array( 'a' => $first, 'b' => $something & \MyClass::$somethingElse ); /* testBitwiseAndG */ $a = $something & $somethingElse; /* testBitwiseAndH */ function myFunction($a = 10 & 20) {} /* testBitwiseAndI */ $closure = function ($a = MY_CONSTANT & parent::OTHER_CONSTANT) {}; /* testFunctionReturnByReference */ function &myFunction() {} /* testFunctionPassByReferenceA */ function myFunction( &$a ) {} /* testFunctionPassByReferenceB */ function myFunction( $a, &$b ) {} /* testFunctionPassByReferenceC */ $closure = function ( &$a ) {}; /* testFunctionPassByReferenceD */ $closure = function ( $a, &$b ) {}; /* testFunctionPassByReferenceE */ function myFunction(array &$one) {} /* testFunctionPassByReferenceF */ $closure = function (\MyClass &$one) {}; /* testFunctionPassByReferenceG */ $closure = function myFunc($param, &...$moreParams) {}; /* testForeachValueByReference */ foreach( $array as $key => &$value ) {} /* testForeachKeyByReference */ foreach( $array as &$key => $value ) {} /* testArrayValueByReferenceA */ $a = [ 'a' => &$something ]; /* testArrayValueByReferenceB */ $a = [ 'a' => $something, 'b' => &$somethingElse ]; /* testArrayValueByReferenceC */ $a = [ &$something ]; /* testArrayValueByReferenceD */ $a = [ $something, &$somethingElse ]; /* testArrayValueByReferenceE */ $a = array( 'a' => &$something ); /* testArrayValueByReferenceF */ $a = array( 'a' => $something, 'b' => &$somethingElse ); /* testArrayValueByReferenceG */ $a = array( &$something ); /* testArrayValueByReferenceH */ $a = array( $something, &$somethingElse ); /* testAssignByReferenceA */ $b = &$something; /* testAssignByReferenceB */ $b =& $something; /* testAssignByReferenceC */ $b .= &$something; /* testAssignByReferenceD */ $myValue = &$obj->getValue(); /* testAssignByReferenceE */ $collection = &collector(); /* testPassByReferenceA */ functionCall(&$something, $somethingElse); /* testPassByReferenceB */ functionCall($something, &$somethingElse); /* testPassByReferenceC */ functionCall($something, &$this->somethingElse); /* testPassByReferenceD */ functionCall($something, &self::$somethingElse); /* testPassByReferenceE */ functionCall($something, &parent::$somethingElse); /* testPassByReferenceF */ functionCall($something, &static::$somethingElse); /* testPassByReferenceG */ functionCall($something, &SomeClass::$somethingElse); /* testPassByReferenceH */ functionCall(&\SomeClass::$somethingElse); /* testPassByReferenceI */ functionCall($something, &\SomeNS\SomeClass::$somethingElse); /* testPassByReferenceJ */ functionCall($something, &namespace\SomeClass::$somethingElse); /* testNewByReferenceA */ $foobar2 = &new Foobar(); /* testNewByReferenceB */ functionCall( $something , &new Foobar() ); /* testUseByReference */ $closure = function() use (&$var){}; /* testArrowFunctionReturnByReference */ fn&($x) => $x; PHP_CodeSniffer-3.5.4/tests/Core/File/IsReferenceTest.php0000644000076500000240000001326213614652361022774 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests\Core\File; use PHP_CodeSniffer\Tests\Core\AbstractMethodUnitTest; class IsReferenceTest extends AbstractMethodUnitTest { /** * Test a class that extends another. * * @param string $identifier Comment which precedes the test case. * @param bool $expected Expected function output. * * @dataProvider dataIsReference * * @return void */ public function testIsReference($identifier, $expected) { $bitwiseAnd = $this->getTargetToken($identifier, T_BITWISE_AND); $result = self::$phpcsFile->isReference($bitwiseAnd); $this->assertSame($expected, $result); }//end testIsReference() /** * Data provider for the IsReference test. * * @see testIsReference() * * @return array */ public function dataIsReference() { return [ [ '/* testBitwiseAndA */', false, ], [ '/* testBitwiseAndB */', false, ], [ '/* testBitwiseAndC */', false, ], [ '/* testBitwiseAndD */', false, ], [ '/* testBitwiseAndE */', false, ], [ '/* testBitwiseAndF */', false, ], [ '/* testBitwiseAndG */', false, ], [ '/* testBitwiseAndH */', false, ], [ '/* testBitwiseAndI */', false, ], [ '/* testFunctionReturnByReference */', true, ], [ '/* testFunctionPassByReferenceA */', true, ], [ '/* testFunctionPassByReferenceB */', true, ], [ '/* testFunctionPassByReferenceC */', true, ], [ '/* testFunctionPassByReferenceD */', true, ], [ '/* testFunctionPassByReferenceE */', true, ], [ '/* testFunctionPassByReferenceF */', true, ], [ '/* testFunctionPassByReferenceG */', true, ], [ '/* testForeachValueByReference */', true, ], [ '/* testForeachKeyByReference */', true, ], [ '/* testArrayValueByReferenceA */', true, ], [ '/* testArrayValueByReferenceB */', true, ], [ '/* testArrayValueByReferenceC */', true, ], [ '/* testArrayValueByReferenceD */', true, ], [ '/* testArrayValueByReferenceE */', true, ], [ '/* testArrayValueByReferenceF */', true, ], [ '/* testArrayValueByReferenceG */', true, ], [ '/* testArrayValueByReferenceH */', true, ], [ '/* testAssignByReferenceA */', true, ], [ '/* testAssignByReferenceB */', true, ], [ '/* testAssignByReferenceC */', true, ], [ '/* testAssignByReferenceD */', true, ], [ '/* testAssignByReferenceE */', true, ], [ '/* testPassByReferenceA */', true, ], [ '/* testPassByReferenceB */', true, ], [ '/* testPassByReferenceC */', true, ], [ '/* testPassByReferenceD */', true, ], [ '/* testPassByReferenceE */', true, ], [ '/* testPassByReferenceF */', true, ], [ '/* testPassByReferenceG */', true, ], [ '/* testPassByReferenceH */', true, ], [ '/* testPassByReferenceI */', true, ], [ '/* testPassByReferenceJ */', true, ], [ '/* testNewByReferenceA */', true, ], [ '/* testNewByReferenceB */', true, ], [ '/* testUseByReference */', true, ], [ '/* testArrowFunctionReturnByReference */', true, ], ]; }//end dataIsReference() }//end class PHP_CodeSniffer-3.5.4/tests/Core/Filters/Filter/AcceptTest.xml0000644000076500000240000000124513614652361023766 0ustar gsherwoodstaff Ruleset to test the filtering based on exclude patterns. */something/* */Other/Main\.php$ /anything/* /YetAnother/Main\.php PHP_CodeSniffer-3.5.4/tests/Core/Filters/Filter/AcceptTest.php0000644000076500000240000001006713614652361023757 0ustar gsherwoodstaff * @author Juliette Reinders Folmer * @copyright 2019 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests\Core\Filters\Filter; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Filters\Filter; use PHP_CodeSniffer\Ruleset; use PHPUnit\Framework\TestCase; class AcceptTest extends TestCase { /** * The Config object. * * @var \PHP_CodeSniffer\Config */ protected static $config; /** * The Ruleset object. * * @var \PHP_CodeSniffer\Ruleset */ protected static $ruleset; /** * Initialize the test. * * @return void */ public function setUp() { if ($GLOBALS['PHP_CODESNIFFER_PEAR'] === true) { // PEAR installs test and sniff files into different locations // so these tests will not pass as they directly reference files // by relative location. $this->markTestSkipped('Test cannot run from a PEAR install'); } }//end setUp() /** * Initialize the config and ruleset objects based on the `AcceptTest.xml` ruleset file. * * @return void */ public static function setUpBeforeClass() { if ($GLOBALS['PHP_CODESNIFFER_PEAR'] === true) { // This test will be skipped. return; } $standard = __DIR__.'/'.basename(__FILE__, '.php').'.xml'; self::$config = new Config(["--standard=$standard", "--ignore=*/somethingelse/*"]); self::$ruleset = new Ruleset(self::$config); }//end setUpBeforeClass() /** * Test filtering a file list for excluded paths. * * @param array $inputPaths List of file paths to be filtered. * @param array $expectedOutput Expected filtering result. * * @dataProvider dataExcludePatterns * * @return void */ public function testExcludePatterns($inputPaths, $expectedOutput) { $fakeDI = new \RecursiveArrayIterator($inputPaths); $filter = new Filter($fakeDI, '/', self::$config, self::$ruleset); $iterator = new \RecursiveIteratorIterator($filter); $files = []; foreach ($iterator as $file) { $files[] = $file; } $this->assertEquals($expectedOutput, $files); }//end testExcludePatterns() /** * Data provider. * * @see testExcludePatterns * * @return array */ public function dataExcludePatterns() { $testCases = [ // Test top-level exclude patterns. [ [ '/path/to/src/Main.php', '/path/to/src/Something/Main.php', '/path/to/src/Somethingelse/Main.php', '/path/to/src/Other/Main.php', ], ['/path/to/src/Main.php'], ], // Test ignoring standard/sniff specific exclude patterns. [ [ '/path/to/src/generic-project/Main.php', '/path/to/src/generic/Main.php', '/path/to/src/anything-generic/Main.php', ], [ '/path/to/src/generic-project/Main.php', '/path/to/src/generic/Main.php', '/path/to/src/anything-generic/Main.php', ], ], ]; // Allow these tests to work on Windows as well. if (DIRECTORY_SEPARATOR === '\\') { foreach ($testCases as $key => $case) { foreach ($case as $nr => $param) { foreach ($param as $file => $value) { $testCases[$key][$nr][$file] = strtr($value, '/', '\\'); } } } } return $testCases; }//end dataExcludePatterns() }//end class PHP_CodeSniffer-3.5.4/tests/Core/Ruleset/RuleInclusionTest.php0000644000076500000240000002027413614652361024142 0ustar gsherwoodstaff * @copyright 2019 Juliette Reinders Folmer. All rights reserved. * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests\Core\Ruleset; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Ruleset; use PHPUnit\Framework\TestCase; class RuleInclusionTest extends TestCase { /** * The Ruleset object. * * @var \PHP_CodeSniffer\Ruleset */ protected static $ruleset; /** * Initialize the test. * * @return void */ public function setUp() { if ($GLOBALS['PHP_CODESNIFFER_PEAR'] === true) { // PEAR installs test and sniff files into different locations // so these tests will not pass as they directly reference files // by relative location. $this->markTestSkipped('Test cannot run from a PEAR install'); } }//end setUp() /** * Initialize the config and ruleset objects based on the `RuleInclusionTest.xml` ruleset file. * * @return void */ public static function setUpBeforeClass() { if ($GLOBALS['PHP_CODESNIFFER_PEAR'] === true) { // This test will be skipped. return; } $standard = __DIR__.'/'.basename(__FILE__, '.php').'.xml'; $config = new Config(["--standard=$standard"]); self::$ruleset = new Ruleset($config); }//end setUpBeforeClass() /** * Test that sniffs are registered. * * @return void */ public function testHasSniffCodes() { $this->assertObjectHasAttribute('sniffCodes', self::$ruleset); $this->assertCount(14, self::$ruleset->sniffCodes); }//end testHasSniffCodes() /** * Test that sniffs are correctly registered, independently on the syntax used to include the sniff. * * @param string $key Expected array key. * @param string $value Expected array value. * * @dataProvider dataRegisteredSniffCodes * * @return void */ public function testRegisteredSniffCodes($key, $value) { $this->assertArrayHasKey($key, self::$ruleset->sniffCodes); $this->assertSame($value, self::$ruleset->sniffCodes[$key]); }//end testRegisteredSniffCodes() /** * Data provider. * * @see self::testRegisteredSniffCodes() * * @return array */ public function dataRegisteredSniffCodes() { return [ [ 'PSR1.Classes.ClassDeclaration', 'PHP_CodeSniffer\Standards\PSR1\Sniffs\Classes\ClassDeclarationSniff', ], [ 'PSR1.Files.SideEffects', 'PHP_CodeSniffer\Standards\PSR1\Sniffs\Files\SideEffectsSniff', ], [ 'PSR1.Methods.CamelCapsMethodName', 'PHP_CodeSniffer\Standards\PSR1\Sniffs\Methods\CamelCapsMethodNameSniff', ], [ 'Generic.PHP.DisallowAlternativePHPTags', 'PHP_CodeSniffer\Standards\Generic\Sniffs\PHP\DisallowAlternativePHPTagsSniff', ], [ 'Generic.PHP.DisallowShortOpenTag', 'PHP_CodeSniffer\Standards\Generic\Sniffs\PHP\DisallowShortOpenTagSniff', ], [ 'Generic.Files.ByteOrderMark', 'PHP_CodeSniffer\Standards\Generic\Sniffs\Files\ByteOrderMarkSniff', ], [ 'Squiz.Classes.ValidClassName', 'PHP_CodeSniffer\Standards\Squiz\Sniffs\Classes\ValidClassNameSniff', ], [ 'Generic.NamingConventions.UpperCaseConstantName', 'PHP_CodeSniffer\Standards\Generic\Sniffs\NamingConventions\UpperCaseConstantNameSniff', ], [ 'Zend.NamingConventions.ValidVariableName', 'PHP_CodeSniffer\Standards\Zend\Sniffs\NamingConventions\ValidVariableNameSniff', ], [ 'Generic.Arrays.ArrayIndent', 'PHP_CodeSniffer\Standards\Generic\Sniffs\Arrays\ArrayIndentSniff', ], [ 'Generic.Metrics.CyclomaticComplexity', 'PHP_CodeSniffer\Standards\Generic\Sniffs\Metrics\CyclomaticComplexitySniff', ], [ 'Generic.Files.LineLength', 'PHP_CodeSniffer\Standards\Generic\Sniffs\Files\LineLengthSniff', ], [ 'Generic.NamingConventions.CamelCapsFunctionName', 'PHP_CodeSniffer\Standards\Generic\Sniffs\NamingConventions\CamelCapsFunctionNameSniff', ], [ 'Generic.Metrics.NestingLevel', 'PHP_CodeSniffer\Standards\Generic\Sniffs\Metrics\NestingLevelSniff', ], ]; }//end dataRegisteredSniffCodes() /** * Test that setting properties for standards, categories, sniffs works for all supported rule * inclusion methods. * * @param string $sniffClass The name of the sniff class. * @param string $propertyName The name of the changed property. * @param mixed $expectedValue The value expected for the property. * * @dataProvider dataSettingProperties * * @return void */ public function testSettingProperties($sniffClass, $propertyName, $expectedValue) { $this->assertObjectHasAttribute('sniffs', self::$ruleset); $this->assertArrayHasKey($sniffClass, self::$ruleset->sniffs); $this->assertObjectHasAttribute($propertyName, self::$ruleset->sniffs[$sniffClass]); $actualValue = self::$ruleset->sniffs[$sniffClass]->$propertyName; $this->assertSame($expectedValue, $actualValue); }//end testSettingProperties() /** * Data provider. * * @see self::testSettingProperties() * * @return array */ public function dataSettingProperties() { return [ 'ClassDeclarationSniff' => [ 'PHP_CodeSniffer\Standards\PSR1\Sniffs\Classes\ClassDeclarationSniff', 'setforallsniffs', true, ], 'SideEffectsSniff' => [ 'PHP_CodeSniffer\Standards\PSR1\Sniffs\Files\SideEffectsSniff', 'setforallsniffs', true, ], 'ValidVariableNameSniff' => [ 'PHP_CodeSniffer\Standards\Zend\Sniffs\NamingConventions\ValidVariableNameSniff', 'setforallincategory', true, ], 'ArrayIndentSniff' => [ 'PHP_CodeSniffer\Standards\Generic\Sniffs\Arrays\ArrayIndentSniff', 'indent', '2', ], 'LineLengthSniff' => [ 'PHP_CodeSniffer\Standards\Generic\Sniffs\Files\LineLengthSniff', 'lineLimit', '10', ], 'CamelCapsFunctionNameSniff' => [ 'PHP_CodeSniffer\Standards\Generic\Sniffs\NamingConventions\CamelCapsFunctionNameSniff', 'strict', false, ], 'NestingLevelSniff-nestingLevel' => [ 'PHP_CodeSniffer\Standards\Generic\Sniffs\Metrics\NestingLevelSniff', 'nestingLevel', '2', ], 'NestingLevelSniff-setforsniffsinincludedruleset' => [ 'PHP_CodeSniffer\Standards\Generic\Sniffs\Metrics\NestingLevelSniff', 'setforsniffsinincludedruleset', true, ], // Testing that setting a property at error code level does *not* work. 'CyclomaticComplexitySniff' => [ 'PHP_CodeSniffer\Standards\Generic\Sniffs\Metrics\CyclomaticComplexitySniff', 'complexity', 10, ], ]; }//end dataSettingProperties() }//end class PHP_CodeSniffer-3.5.4/tests/Core/Ruleset/RuleInclusionTest.xml0000644000076500000240000000247413614652361024155 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/tests/Core/Ruleset/RuleInclusionTest-include.xml0000644000076500000240000000057613614652361025577 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/tests/Core/Ruleset/RuleInclusionAbsoluteLinuxTest.php0000644000076500000240000000663613614652361026667 0ustar gsherwoodstaff * @copyright 2019 Juliette Reinders Folmer. All rights reserved. * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests\Core\Ruleset; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Ruleset; use PHPUnit\Framework\TestCase; class RuleInclusionAbsoluteLinuxTest extends TestCase { /** * The Ruleset object. * * @var \PHP_CodeSniffer\Ruleset */ protected $ruleset; /** * Path to the ruleset file. * * @var string */ private $standard = ''; /** * The original content of the ruleset. * * @var string */ private $contents = ''; /** * Initialize the config and ruleset objects. * * @return void */ public function setUp() { if ($GLOBALS['PHP_CODESNIFFER_PEAR'] === true) { // PEAR installs test and sniff files into different locations // so these tests will not pass as they directly reference files // by relative location. $this->markTestSkipped('Test cannot run from a PEAR install'); } $this->standard = __DIR__.'/'.basename(__FILE__, '.php').'.xml'; $repoRootDir = dirname(dirname(dirname(__DIR__))); // On-the-fly adjust the ruleset test file to be able to test sniffs included with absolute paths. $contents = file_get_contents($this->standard); $this->contents = $contents; $newPath = $repoRootDir; if (DIRECTORY_SEPARATOR === '\\') { $newPath = str_replace('\\', '/', $repoRootDir); } $adjusted = str_replace('%path_slash_forward%', $newPath, $contents); if (file_put_contents($this->standard, $adjusted) === false) { $this->markTestSkipped('On the fly ruleset adjustment failed'); } // Initialize the config and ruleset objects for the test. $config = new Config(["--standard={$this->standard}"]); $this->ruleset = new Ruleset($config); }//end setUp() /** * Reset ruleset file. * * @return void */ public function tearDown() { file_put_contents($this->standard, $this->contents); }//end tearDown() /** * Test that sniffs registed with a Linux absolute path are correctly recognized and that * properties are correctly set for them. * * @return void */ public function testLinuxStylePathRuleInclusion() { // Test that the sniff is correctly registered. $this->assertObjectHasAttribute('sniffCodes', $this->ruleset); $this->assertCount(1, $this->ruleset->sniffCodes); $this->assertArrayHasKey('Generic.Formatting.SpaceAfterNot', $this->ruleset->sniffCodes); $this->assertSame( 'PHP_CodeSniffer\Standards\Generic\Sniffs\Formatting\SpaceAfterNotSniff', $this->ruleset->sniffCodes['Generic.Formatting.SpaceAfterNot'] ); // Test that the sniff properties are correctly set. $this->assertSame( '10', $this->ruleset->sniffs['PHP_CodeSniffer\Standards\Generic\Sniffs\Formatting\SpaceAfterNotSniff']->spacing ); }//end testLinuxStylePathRuleInclusion() }//end class PHP_CodeSniffer-3.5.4/tests/Core/Ruleset/RuleInclusionAbsoluteLinuxTest.xml0000644000076500000240000000076113614652361026671 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/tests/Core/Ruleset/RuleInclusionAbsoluteWindowsTest.php0000644000076500000240000000670113614652361027213 0ustar gsherwoodstaff * @copyright 2019 Juliette Reinders Folmer. All rights reserved. * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests\Core\Ruleset; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Ruleset; use PHPUnit\Framework\TestCase; class RuleInclusionAbsoluteWindowsTest extends TestCase { /** * The Ruleset object. * * @var \PHP_CodeSniffer\Ruleset */ protected $ruleset; /** * Path to the ruleset file. * * @var string */ private $standard = ''; /** * The original content of the ruleset. * * @var string */ private $contents = ''; /** * Initialize the config and ruleset objects. * * @return void */ public function setUp() { if (DIRECTORY_SEPARATOR === '/') { $this->markTestSkipped('Windows specific test'); } if ($GLOBALS['PHP_CODESNIFFER_PEAR'] === true) { // PEAR installs test and sniff files into different locations // so these tests will not pass as they directly reference files // by relative location. $this->markTestSkipped('Test cannot run from a PEAR install'); } $this->standard = __DIR__.'/'.basename(__FILE__, '.php').'.xml'; $repoRootDir = dirname(dirname(dirname(__DIR__))); // On-the-fly adjust the ruleset test file to be able to test sniffs included with absolute paths. $contents = file_get_contents($this->standard); $this->contents = $contents; $adjusted = str_replace('%path_slash_back%', $repoRootDir, $contents); if (file_put_contents($this->standard, $adjusted) === false) { $this->markTestSkipped('On the fly ruleset adjustment failed'); } // Initialize the config and ruleset objects for the test. $config = new Config(["--standard={$this->standard}"]); $this->ruleset = new Ruleset($config); }//end setUp() /** * Reset ruleset file. * * @return void */ public function tearDown() { if (DIRECTORY_SEPARATOR !== '/') { file_put_contents($this->standard, $this->contents); } }//end tearDown() /** * Test that sniffs registed with a Windows absolute path are correctly recognized and that * properties are correctly set for them. * * @return void */ public function testWindowsStylePathRuleInclusion() { // Test that the sniff is correctly registered. $this->assertObjectHasAttribute('sniffCodes', $this->ruleset); $this->assertCount(1, $this->ruleset->sniffCodes); $this->assertArrayHasKey('Generic.Formatting.SpaceAfterCast', $this->ruleset->sniffCodes); $this->assertSame( 'PHP_CodeSniffer\Standards\Generic\Sniffs\Formatting\SpaceAfterCastSniff', $this->ruleset->sniffCodes['Generic.Formatting.SpaceAfterCast'] ); // Test that the sniff property is correctly set. $this->assertSame( '10', $this->ruleset->sniffs['PHP_CodeSniffer\Standards\Generic\Sniffs\Formatting\SpaceAfterCastSniff']->spacing ); }//end testWindowsStylePathRuleInclusion() }//end class PHP_CodeSniffer-3.5.4/tests/Core/Ruleset/RuleInclusionAbsoluteWindowsTest.xml0000644000076500000240000000075613614652361027230 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/tests/Core/Sniffs/AbstractArraySniffTest.inc0000644000076500000240000000162013614652361024660 0ustar gsherwoodstaff1,'2'=>2,'3'=>3]; /* testMissingKeys */ $foo = ['1'=>1,2,'3'=>3]; /* testMultiTokenKeys */ $paths = array( Init::ROOT_DIR.'/a' => 'a', Init::ROOT_DIR.'/b' => 'b', ); /* testMissingKeysCoalesceTernary */ return [ $a => static function () { return [1,2,3]; }, $b ?? $c, $d ? [$e] : [$f], ]; /* testTernaryValues */ $foo = [ '1' => $row['status'] === 'rejected' ? self::REJECTED_CODE : self::VERIFIED_CODE, '2' => in_array($row['status'], array('notverified', 'unverified'), true) ? self::STATUS_PENDING : self::STATUS_VERIFIED, '3' => strtotime($row['date']), ]; /* testHeredocValues */ $foo = array( << '1', 2 => fn ($x) => yield 'a' => $x, 3 => '3', ); PHP_CodeSniffer-3.5.4/tests/Core/Sniffs/AbstractArraySniffTest.php0000644000076500000240000002007413614652361024702 0ustar gsherwoodstaff * @copyright 2006-2020 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests\Core\Sniffs; use PHP_CodeSniffer\Tests\Core\AbstractMethodUnitTest; class AbstractArraySniffTest extends AbstractMethodUnitTest { /** * The sniff objects we are testing. * * This extends the \PHP_CodeSniffer\Sniffs\AbstractArraySniff class to make the * internal workings of the sniff observable. * * @var \PHP_CodeSniffer\Sniffs\AbstractArraySniffTestable */ protected static $sniff; /** * Initialize & tokenize \PHP_CodeSniffer\Files\File with code from the test case file. * * The test case file for a unit test class has to be in the same directory * directory and use the same file name as the test class, using the .inc extension. * * @return void */ public static function setUpBeforeClass() { self::$sniff = new AbstractArraySniffTestable(); parent::setUpBeforeClass(); }//end setUpBeforeClass() /** * Test an array of simple values only. * * @return void */ public function testSimpleValues() { $token = $this->getTargetToken('/* testSimpleValues */', T_OPEN_SHORT_ARRAY); self::$sniff->process(self::$phpcsFile, $token); $expected = [ 0 => ['value_start' => ($token + 1)], 1 => ['value_start' => ($token + 3)], 2 => ['value_start' => ($token + 5)], ]; $this->assertSame($expected, self::$sniff->indicies); }//end testSimpleValues() /** * Test an array of simple keys and values. * * @return void */ public function testSimpleKeyValues() { $token = $this->getTargetToken('/* testSimpleKeyValues */', T_OPEN_SHORT_ARRAY); self::$sniff->process(self::$phpcsFile, $token); $expected = [ 0 => [ 'index_start' => ($token + 1), 'index_end' => ($token + 1), 'arrow' => ($token + 2), 'value_start' => ($token + 3), ], 1 => [ 'index_start' => ($token + 5), 'index_end' => ($token + 5), 'arrow' => ($token + 6), 'value_start' => ($token + 7), ], 2 => [ 'index_start' => ($token + 9), 'index_end' => ($token + 9), 'arrow' => ($token + 10), 'value_start' => ($token + 11), ], ]; $this->assertSame($expected, self::$sniff->indicies); }//end testSimpleKeyValues() /** * Test an array of simple keys and values. * * @return void */ public function testMissingKeys() { $token = $this->getTargetToken('/* testMissingKeys */', T_OPEN_SHORT_ARRAY); self::$sniff->process(self::$phpcsFile, $token); $expected = [ 0 => [ 'index_start' => ($token + 1), 'index_end' => ($token + 1), 'arrow' => ($token + 2), 'value_start' => ($token + 3), ], 1 => [ 'value_start' => ($token + 5), ], 2 => [ 'index_start' => ($token + 7), 'index_end' => ($token + 7), 'arrow' => ($token + 8), 'value_start' => ($token + 9), ], ]; $this->assertSame($expected, self::$sniff->indicies); }//end testMissingKeys() /** * Test an array with keys that span multiple tokens. * * @return void */ public function testMultiTokenKeys() { $token = $this->getTargetToken('/* testMultiTokenKeys */', T_ARRAY); self::$sniff->process(self::$phpcsFile, $token); $expected = [ 0 => [ 'index_start' => ($token + 4), 'index_end' => ($token + 8), 'arrow' => ($token + 10), 'value_start' => ($token + 12), ], 1 => [ 'index_start' => ($token + 16), 'index_end' => ($token + 20), 'arrow' => ($token + 22), 'value_start' => ($token + 24), ], ]; $this->assertSame($expected, self::$sniff->indicies); }//end testMultiTokenKeys() /** * Test an array of simple keys and values. * * @return void */ public function testMissingKeysCoalesceTernary() { $token = $this->getTargetToken('/* testMissingKeysCoalesceTernary */', T_OPEN_SHORT_ARRAY); self::$sniff->process(self::$phpcsFile, $token); $expected = [ 0 => [ 'index_start' => ($token + 3), 'index_end' => ($token + 3), 'arrow' => ($token + 5), 'value_start' => ($token + 7), ], 1 => [ 'value_start' => ($token + 31), ], 2 => [ 'value_start' => ($token + 39), ], ]; $this->assertSame($expected, self::$sniff->indicies); }//end testMissingKeysCoalesceTernary() /** * Test an array of ternary values. * * @return void */ public function testTernaryValues() { $token = $this->getTargetToken('/* testTernaryValues */', T_OPEN_SHORT_ARRAY); self::$sniff->process(self::$phpcsFile, $token); $expected = [ 0 => [ 'index_start' => ($token + 3), 'index_end' => ($token + 3), 'arrow' => ($token + 5), 'value_start' => ($token + 7), ], 1 => [ 'index_start' => ($token + 32), 'index_end' => ($token + 32), 'arrow' => ($token + 34), 'value_start' => ($token + 36), ], 2 => [ 'index_start' => ($token + 72), 'index_end' => ($token + 72), 'arrow' => ($token + 74), 'value_start' => ($token + 76), ], ]; $this->assertSame($expected, self::$sniff->indicies); }//end testTernaryValues() /** * Test an array of heredocs. * * @return void */ public function testHeredocValues() { $token = $this->getTargetToken('/* testHeredocValues */', T_ARRAY); self::$sniff->process(self::$phpcsFile, $token); $expected = [ 0 => [ 'value_start' => ($token + 4), ], 1 => [ 'value_start' => ($token + 10), ], ]; $this->assertSame($expected, self::$sniff->indicies); }//end testHeredocValues() /** * Test an array of with an arrow function as a value. * * @return void */ public function testArrowFunctionValue() { $token = $this->getTargetToken('/* testArrowFunctionValue */', T_ARRAY); self::$sniff->process(self::$phpcsFile, $token); $expected = [ 0 => [ 'index_start' => ($token + 4), 'index_end' => ($token + 4), 'arrow' => ($token + 6), 'value_start' => ($token + 8), ], 1 => [ 'index_start' => ($token + 12), 'index_end' => ($token + 12), 'arrow' => ($token + 14), 'value_start' => ($token + 16), ], 2 => [ 'index_start' => ($token + 34), 'index_end' => ($token + 34), 'arrow' => ($token + 36), 'value_start' => ($token + 38), ], ]; $this->assertSame($expected, self::$sniff->indicies); }//end testArrowFunctionValue() }//end class PHP_CodeSniffer-3.5.4/tests/Core/Sniffs/AbstractArraySniffTestable.php0000644000076500000240000000457613614652361025537 0ustar gsherwoodstaff * @copyright 2006-2020 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests\Core\Sniffs; use PHP_CodeSniffer\Sniffs\AbstractArraySniff; class AbstractArraySniffTestable extends AbstractArraySniff { /** * The array indicies that were found during processing. * * @var array */ public $indicies = []; /** * Processes a single-line array definition. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being checked. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param int $arrayStart The token that starts the array definition. * @param int $arrayEnd The token that ends the array definition. * @param array $indices An array of token positions for the array keys, * double arrows, and values. * * @return void */ public function processSingleLineArray($phpcsFile, $stackPtr, $arrayStart, $arrayEnd, $indices) { $this->indicies = $indices; }//end processSingleLineArray() /** * Processes a multi-line array definition. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being checked. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param int $arrayStart The token that starts the array definition. * @param int $arrayEnd The token that ends the array definition. * @param array $indices An array of token positions for the array keys, * double arrows, and values. * * @return void */ public function processMultiLineArray($phpcsFile, $stackPtr, $arrayStart, $arrayEnd, $indices) { $this->indicies = $indices; }//end processMultiLineArray() }//end class PHP_CodeSniffer-3.5.4/tests/Core/Tokenizer/AnonClassParenthesisOwnerTest.inc0000644000076500000240000000054313614652361026757 0ustar gsherwoodstaff * @copyright 2019 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests\Core\Tokenizer; use PHP_CodeSniffer\Tests\Core\AbstractMethodUnitTest; class AnonClassParenthesisOwnerTest extends AbstractMethodUnitTest { /** * Test that anonymous class tokens without parenthesis do not get assigned a parenthesis owner. * * @param string $testMarker The comment which prefaces the target token in the test file. * * @dataProvider dataAnonClassNoParentheses * @covers PHP_CodeSniffer\Tokenizers\PHP::processAdditional * * @return void */ public function testAnonClassNoParentheses($testMarker) { $tokens = self::$phpcsFile->getTokens(); $anonClass = $this->getTargetToken($testMarker, T_ANON_CLASS); $this->assertFalse(array_key_exists('parenthesis_owner', $tokens[$anonClass])); $this->assertFalse(array_key_exists('parenthesis_opener', $tokens[$anonClass])); $this->assertFalse(array_key_exists('parenthesis_closer', $tokens[$anonClass])); }//end testAnonClassNoParentheses() /** * Test that the next open/close parenthesis after an anonymous class without parenthesis * do not get assigned the anonymous class as a parenthesis owner. * * @param string $testMarker The comment which prefaces the target token in the test file. * * @dataProvider dataAnonClassNoParentheses * @covers PHP_CodeSniffer\Tokenizers\PHP::processAdditional * * @return void */ public function testAnonClassNoParenthesesNextOpenClose($testMarker) { $tokens = self::$phpcsFile->getTokens(); $function = $this->getTargetToken($testMarker, T_FUNCTION); $opener = $this->getTargetToken($testMarker, T_OPEN_PARENTHESIS); $this->assertTrue(array_key_exists('parenthesis_owner', $tokens[$opener])); $this->assertSame($function, $tokens[$opener]['parenthesis_owner']); $closer = $this->getTargetToken($testMarker, T_CLOSE_PARENTHESIS); $this->assertTrue(array_key_exists('parenthesis_owner', $tokens[$closer])); $this->assertSame($function, $tokens[$closer]['parenthesis_owner']); }//end testAnonClassNoParenthesesNextOpenClose() /** * Data provider. * * @see testAnonClassNoParentheses() * @see testAnonClassNoParenthesesNextOpenClose() * * @return array */ public function dataAnonClassNoParentheses() { return [ ['/* testNoParentheses */'], ['/* testNoParenthesesAndEmptyTokens */'], ]; }//end dataAnonClassNoParentheses() /** * Test that anonymous class tokens with parenthesis get assigned a parenthesis owner, * opener and closer; and that the opener/closer get the anonymous class assigned as owner. * * @param string $testMarker The comment which prefaces the target token in the test file. * * @dataProvider dataAnonClassWithParentheses * @covers PHP_CodeSniffer\Tokenizers\PHP::processAdditional * * @return void */ public function testAnonClassWithParentheses($testMarker) { $tokens = self::$phpcsFile->getTokens(); $anonClass = $this->getTargetToken($testMarker, T_ANON_CLASS); $opener = $this->getTargetToken($testMarker, T_OPEN_PARENTHESIS); $closer = $this->getTargetToken($testMarker, T_CLOSE_PARENTHESIS); $this->assertTrue(array_key_exists('parenthesis_owner', $tokens[$anonClass])); $this->assertTrue(array_key_exists('parenthesis_opener', $tokens[$anonClass])); $this->assertTrue(array_key_exists('parenthesis_closer', $tokens[$anonClass])); $this->assertSame($anonClass, $tokens[$anonClass]['parenthesis_owner']); $this->assertSame($opener, $tokens[$anonClass]['parenthesis_opener']); $this->assertSame($closer, $tokens[$anonClass]['parenthesis_closer']); $this->assertTrue(array_key_exists('parenthesis_owner', $tokens[$opener])); $this->assertTrue(array_key_exists('parenthesis_opener', $tokens[$opener])); $this->assertTrue(array_key_exists('parenthesis_closer', $tokens[$opener])); $this->assertSame($anonClass, $tokens[$opener]['parenthesis_owner']); $this->assertSame($opener, $tokens[$opener]['parenthesis_opener']); $this->assertSame($closer, $tokens[$opener]['parenthesis_closer']); $this->assertTrue(array_key_exists('parenthesis_owner', $tokens[$closer])); $this->assertTrue(array_key_exists('parenthesis_opener', $tokens[$closer])); $this->assertTrue(array_key_exists('parenthesis_closer', $tokens[$closer])); $this->assertSame($anonClass, $tokens[$closer]['parenthesis_owner']); $this->assertSame($opener, $tokens[$closer]['parenthesis_opener']); $this->assertSame($closer, $tokens[$closer]['parenthesis_closer']); }//end testAnonClassWithParentheses() /** * Data provider. * * @see testAnonClassWithParentheses() * * @return array */ public function dataAnonClassWithParentheses() { return [ ['/* testWithParentheses */'], ['/* testWithParenthesesAndEmptyTokens */'], ]; }//end dataAnonClassWithParentheses() }//end class PHP_CodeSniffer-3.5.4/tests/Core/Tokenizer/BackfillFnTokenTest.inc0000644000076500000240000000302313614652361024645 0ustar gsherwoodstaff $x + $y; /* testMixedCase */ $fn1 = Fn($x) => $x + $y; /* testWhitespace */ $fn1 = fn ($x) => $x + $y; /* testComment */ $fn1 = fn /* comment here */ ($x) => $x + $y; /* testFunctionName */ function fn() {} /* testNestedOuter */ $fn = fn($x) => /* testNestedInner */ fn($y) => $x * $y + $z; /* testFunctionCall */ $extended = fn($c) => $callable($factory($c), $c); /* testChainedFunctionCall */ $result = Collection::from([1, 2]) ->map(fn($v) => $v * 2) ->reduce(/* testFunctionArgument */ fn($tmp, $v) => $tmp + $v, 0); /* testClosure */ $extended = fn($c) => $callable(function() { for ($x = 1; $x < 10; $x++) { echo $x; } echo 'done'; }, $c); $result = array_map( /* testReturnType */ static fn(int $number) : int => $number + 1, $numbers ); /* testReference */ fn&($x) => $x; /* testGrouped */ (fn($x) => $x) + $y; /* testArrayValue */ $a = [ 'a' => fn() => return 1, ]; /* testYield */ $a = fn($x) => yield 'k' => $x; /* testNullableNamespace */ $a = fn(?\DateTime $x) : ?\DateTime => $x; /* testSelfReturnType */ fn(self $a) : self => $a; /* testParentReturnType */ fn(parent $a) : parent => $a; /* testCallableReturnType */ fn(callable $a) : callable => $a; /* testArrayReturnType */ fn(array $a) : array => $a; /* testTernary */ $fn = fn($a) => $a ? /* testTernaryThen */ fn() : string => 'a' : /* testTernaryElse */ fn() : string => 'b'; /* testLiveCoding */ // Intentional parse error. This has to be the last test in the file. $fn = fn PHP_CodeSniffer-3.5.4/tests/Core/Tokenizer/BackfillFnTokenTest.php0000644000076500000240000007014113614652361024670 0ustar gsherwoodstaff * @copyright 2019 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests\Core\Tokenizer; use PHP_CodeSniffer\Tests\Core\AbstractMethodUnitTest; class BackfillFnTokenTest extends AbstractMethodUnitTest { /** * Test simple arrow functions. * * @covers PHP_CodeSniffer\Tokenizers\PHP::processAdditional * * @return void */ public function testSimple() { $tokens = self::$phpcsFile->getTokens(); foreach (['/* testStandard */', '/* testMixedCase */'] as $comment) { $token = $this->getTargetToken($comment, T_FN); $this->backfillHelper($token); $this->assertSame($tokens[$token]['scope_opener'], ($token + 5), 'Scope opener is not the arrow token'); $this->assertSame($tokens[$token]['scope_closer'], ($token + 12), 'Scope closer is not the semicolon token'); $opener = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$opener]['scope_opener'], ($token + 5), 'Opener scope opener is not the arrow token'); $this->assertSame($tokens[$opener]['scope_closer'], ($token + 12), 'Opener scope closer is not the semicolon token'); $closer = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$closer]['scope_opener'], ($token + 5), 'Closer scope opener is not the arrow token'); $this->assertSame($tokens[$closer]['scope_closer'], ($token + 12), 'Closer scope closer is not the semicolon token'); } }//end testSimple() /** * Test whitespace inside arrow function definitions. * * @covers PHP_CodeSniffer\Tokenizers\PHP::processAdditional * * @return void */ public function testWhitespace() { $tokens = self::$phpcsFile->getTokens(); $token = $this->getTargetToken('/* testWhitespace */', T_FN); $this->backfillHelper($token); $this->assertSame($tokens[$token]['scope_opener'], ($token + 6), 'Scope opener is not the arrow token'); $this->assertSame($tokens[$token]['scope_closer'], ($token + 13), 'Scope closer is not the semicolon token'); $opener = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$opener]['scope_opener'], ($token + 6), 'Opener scope opener is not the arrow token'); $this->assertSame($tokens[$opener]['scope_closer'], ($token + 13), 'Opener scope closer is not the semicolon token'); $closer = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$closer]['scope_opener'], ($token + 6), 'Closer scope opener is not the arrow token'); $this->assertSame($tokens[$closer]['scope_closer'], ($token + 13), 'Closer scope closer is not the semicolon token'); }//end testWhitespace() /** * Test comments inside arrow function definitions. * * @covers PHP_CodeSniffer\Tokenizers\PHP::processAdditional * * @return void */ public function testComments() { $tokens = self::$phpcsFile->getTokens(); $token = $this->getTargetToken('/* testComment */', T_FN); $this->backfillHelper($token); $this->assertSame($tokens[$token]['scope_opener'], ($token + 8), 'Scope opener is not the arrow token'); $this->assertSame($tokens[$token]['scope_closer'], ($token + 15), 'Scope closer is not the semicolon token'); $opener = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$opener]['scope_opener'], ($token + 8), 'Opener scope opener is not the arrow token'); $this->assertSame($tokens[$opener]['scope_closer'], ($token + 15), 'Opener scope closer is not the semicolon token'); $closer = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$closer]['scope_opener'], ($token + 8), 'Closer scope opener is not the arrow token'); $this->assertSame($tokens[$closer]['scope_closer'], ($token + 15), 'Closer scope closer is not the semicolon token'); }//end testComments() /** * Test a function called fn. * * @covers PHP_CodeSniffer\Tokenizers\PHP::processAdditional * * @return void */ public function testFunctionName() { $tokens = self::$phpcsFile->getTokens(); $token = $this->getTargetToken('/* testFunctionName */', T_FN); $this->assertFalse(array_key_exists('scope_condition', $tokens[$token]), 'Scope condition is set'); $this->assertFalse(array_key_exists('scope_opener', $tokens[$token]), 'Scope opener is set'); $this->assertFalse(array_key_exists('scope_closer', $tokens[$token]), 'Scope closer is set'); $this->assertFalse(array_key_exists('parenthesis_owner', $tokens[$token]), 'Parenthesis owner is set'); $this->assertFalse(array_key_exists('parenthesis_opener', $tokens[$token]), 'Parenthesis opener is set'); $this->assertFalse(array_key_exists('parenthesis_closer', $tokens[$token]), 'Parenthesis closer is set'); }//end testFunctionName() /** * Test nested arrow functions. * * @covers PHP_CodeSniffer\Tokenizers\PHP::processAdditional * * @return void */ public function testNestedOuter() { $tokens = self::$phpcsFile->getTokens(); $token = $this->getTargetToken('/* testNestedOuter */', T_FN); $this->backfillHelper($token); $this->assertSame($tokens[$token]['scope_opener'], ($token + 5), 'Scope opener is not the arrow token'); $this->assertSame($tokens[$token]['scope_closer'], ($token + 25), 'Scope closer is not the semicolon token'); $opener = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$opener]['scope_opener'], ($token + 5), 'Opener scope opener is not the arrow token'); $this->assertSame($tokens[$opener]['scope_closer'], ($token + 25), 'Opener scope closer is not the semicolon token'); $closer = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$closer]['scope_opener'], ($token + 5), 'Closer scope opener is not the arrow token'); $this->assertSame($tokens[$closer]['scope_closer'], ($token + 25), 'Closer scope closer is not the semicolon token'); }//end testNestedOuter() /** * Test nested arrow functions. * * @covers PHP_CodeSniffer\Tokenizers\PHP::processAdditional * * @return void */ public function testNestedInner() { $tokens = self::$phpcsFile->getTokens(); $token = $this->getTargetToken('/* testNestedInner */', T_FN); $this->backfillHelper($token); $this->assertSame($tokens[$token]['scope_opener'], ($token + 5), 'Scope opener is not the arrow token'); $this->assertSame($tokens[$token]['scope_closer'], ($token + 16), 'Scope closer is not the semicolon token'); $opener = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$opener]['scope_opener'], ($token + 5), 'Opener scope opener is not the arrow token'); $this->assertSame($tokens[$opener]['scope_closer'], ($token + 16), 'Opener scope closer is not the semicolon token'); $closer = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$closer]['scope_opener'], ($token + 5), 'Closer scope opener is not the arrow token'); $this->assertSame($tokens[$closer]['scope_closer'], ($token + 16), 'Closer scope closer is not the semicolon token'); }//end testNestedInner() /** * Test arrow functions that call functions. * * @covers PHP_CodeSniffer\Tokenizers\PHP::processAdditional * * @return void */ public function testFunctionCall() { $tokens = self::$phpcsFile->getTokens(); $token = $this->getTargetToken('/* testFunctionCall */', T_FN); $this->backfillHelper($token); $this->assertSame($tokens[$token]['scope_opener'], ($token + 5), 'Scope opener is not the arrow token'); $this->assertSame($tokens[$token]['scope_closer'], ($token + 17), 'Scope closer is not the semicolon token'); $opener = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$opener]['scope_opener'], ($token + 5), 'Opener scope opener is not the arrow token'); $this->assertSame($tokens[$opener]['scope_closer'], ($token + 17), 'Opener scope closer is not the semicolon token'); $closer = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$closer]['scope_opener'], ($token + 5), 'Closer scope opener is not the arrow token'); $this->assertSame($tokens[$closer]['scope_closer'], ($token + 17), 'Closer scope closer is not the semicolon token'); }//end testFunctionCall() /** * Test arrow functions that are included in chained calls. * * @covers PHP_CodeSniffer\Tokenizers\PHP::processAdditional * * @return void */ public function testChainedFunctionCall() { $tokens = self::$phpcsFile->getTokens(); $token = $this->getTargetToken('/* testChainedFunctionCall */', T_FN); $this->backfillHelper($token); $this->assertSame($tokens[$token]['scope_opener'], ($token + 5), 'Scope opener is not the arrow token'); $this->assertSame($tokens[$token]['scope_closer'], ($token + 12), 'Scope closer is not the bracket token'); $opener = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$opener]['scope_opener'], ($token + 5), 'Opener scope opener is not the arrow token'); $this->assertSame($tokens[$opener]['scope_closer'], ($token + 12), 'Opener scope closer is not the bracket token'); $closer = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$closer]['scope_opener'], ($token + 5), 'Closer scope opener is not the arrow token'); $this->assertSame($tokens[$closer]['scope_closer'], ($token + 12), 'Closer scope closer is not the bracket token'); }//end testChainedFunctionCall() /** * Test arrow functions that are used as function arguments. * * @covers PHP_CodeSniffer\Tokenizers\PHP::processAdditional * * @return void */ public function testFunctionArgument() { $tokens = self::$phpcsFile->getTokens(); $token = $this->getTargetToken('/* testFunctionArgument */', T_FN); $this->backfillHelper($token); $this->assertSame($tokens[$token]['scope_opener'], ($token + 8), 'Scope opener is not the arrow token'); $this->assertSame($tokens[$token]['scope_closer'], ($token + 15), 'Scope closer is not the comma token'); $opener = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$opener]['scope_opener'], ($token + 8), 'Opener scope opener is not the arrow token'); $this->assertSame($tokens[$opener]['scope_closer'], ($token + 15), 'Opener scope closer is not the comma token'); $closer = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$closer]['scope_opener'], ($token + 8), 'Closer scope opener is not the arrow token'); $this->assertSame($tokens[$closer]['scope_closer'], ($token + 15), 'Closer scope closer is not the comma token'); }//end testFunctionArgument() /** * Test arrow functions that use closures. * * @covers PHP_CodeSniffer\Tokenizers\PHP::processAdditional * * @return void */ public function testClosure() { $tokens = self::$phpcsFile->getTokens(); $token = $this->getTargetToken('/* testClosure */', T_FN); $this->backfillHelper($token); $this->assertSame($tokens[$token]['scope_opener'], ($token + 5), 'Scope opener is not the arrow token'); $this->assertSame($tokens[$token]['scope_closer'], ($token + 60), 'Scope closer is not the comma token'); $opener = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$opener]['scope_opener'], ($token + 5), 'Opener scope opener is not the arrow token'); $this->assertSame($tokens[$opener]['scope_closer'], ($token + 60), 'Opener scope closer is not the comma token'); $closer = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$closer]['scope_opener'], ($token + 5), 'Closer scope opener is not the arrow token'); $this->assertSame($tokens[$closer]['scope_closer'], ($token + 60), 'Closer scope closer is not the comma token'); }//end testClosure() /** * Test arrow functions with a return type. * * @covers PHP_CodeSniffer\Tokenizers\PHP::processAdditional * * @return void */ public function testReturnType() { $tokens = self::$phpcsFile->getTokens(); $token = $this->getTargetToken('/* testReturnType */', T_FN); $this->backfillHelper($token); $this->assertSame($tokens[$token]['scope_opener'], ($token + 11), 'Scope opener is not the arrow token'); $this->assertSame($tokens[$token]['scope_closer'], ($token + 18), 'Scope closer is not the comma token'); $opener = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$opener]['scope_opener'], ($token + 11), 'Opener scope opener is not the arrow token'); $this->assertSame($tokens[$opener]['scope_closer'], ($token + 18), 'Opener scope closer is not the comma token'); $closer = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$closer]['scope_opener'], ($token + 11), 'Closer scope opener is not the arrow token'); $this->assertSame($tokens[$closer]['scope_closer'], ($token + 18), 'Closer scope closer is not the comma token'); }//end testReturnType() /** * Test arrow functions that return a reference. * * @covers PHP_CodeSniffer\Tokenizers\PHP::processAdditional * * @return void */ public function testReference() { $tokens = self::$phpcsFile->getTokens(); $token = $this->getTargetToken('/* testReference */', T_FN); $this->backfillHelper($token); $this->assertSame($tokens[$token]['scope_opener'], ($token + 6), 'Scope opener is not the arrow token'); $this->assertSame($tokens[$token]['scope_closer'], ($token + 9), 'Scope closer is not the semicolon token'); $opener = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$opener]['scope_opener'], ($token + 6), 'Opener scope opener is not the arrow token'); $this->assertSame($tokens[$opener]['scope_closer'], ($token + 9), 'Opener scope closer is not the semicolon token'); $closer = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$closer]['scope_opener'], ($token + 6), 'Closer scope opener is not the arrow token'); $this->assertSame($tokens[$closer]['scope_closer'], ($token + 9), 'Closer scope closer is not the semicolon token'); }//end testReference() /** * Test arrow functions that are grouped by parenthesis. * * @covers PHP_CodeSniffer\Tokenizers\PHP::processAdditional * * @return void */ public function testGrouped() { $tokens = self::$phpcsFile->getTokens(); $token = $this->getTargetToken('/* testGrouped */', T_FN); $this->backfillHelper($token); $this->assertSame($tokens[$token]['scope_opener'], ($token + 5), 'Scope opener is not the arrow token'); $this->assertSame($tokens[$token]['scope_closer'], ($token + 8), 'Scope closer is not the semicolon token'); $opener = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$opener]['scope_opener'], ($token + 5), 'Opener scope opener is not the arrow token'); $this->assertSame($tokens[$opener]['scope_closer'], ($token + 8), 'Opener scope closer is not the semicolon token'); $closer = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$closer]['scope_opener'], ($token + 5), 'Closer scope opener is not the arrow token'); $this->assertSame($tokens[$closer]['scope_closer'], ($token + 8), 'Closer scope closer is not the semicolon token'); }//end testGrouped() /** * Test arrow functions that are used as array values. * * @covers PHP_CodeSniffer\Tokenizers\PHP::processAdditional * * @return void */ public function testArrayValue() { $tokens = self::$phpcsFile->getTokens(); $token = $this->getTargetToken('/* testArrayValue */', T_FN); $this->backfillHelper($token); $this->assertSame($tokens[$token]['scope_opener'], ($token + 4), 'Scope opener is not the arrow token'); $this->assertSame($tokens[$token]['scope_closer'], ($token + 9), 'Scope closer is not the comma token'); $opener = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$opener]['scope_opener'], ($token + 4), 'Opener scope opener is not the arrow token'); $this->assertSame($tokens[$opener]['scope_closer'], ($token + 9), 'Opener scope closer is not the comma token'); $closer = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$closer]['scope_opener'], ($token + 4), 'Closer scope opener is not the arrow token'); $this->assertSame($tokens[$closer]['scope_closer'], ($token + 9), 'Closer scope closer is not the comma token'); }//end testArrayValue() /** * Test arrow functions that use the yield keyword. * * @covers PHP_CodeSniffer\Tokenizers\PHP::processAdditional * * @return void */ public function testYield() { $tokens = self::$phpcsFile->getTokens(); $token = $this->getTargetToken('/* testYield */', T_FN); $this->backfillHelper($token); $this->assertSame($tokens[$token]['scope_opener'], ($token + 5), 'Scope opener is not the arrow token'); $this->assertSame($tokens[$token]['scope_closer'], ($token + 14), 'Scope closer is not the semicolon token'); $opener = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$opener]['scope_opener'], ($token + 5), 'Opener scope opener is not the arrow token'); $this->assertSame($tokens[$opener]['scope_closer'], ($token + 14), 'Opener scope closer is not the semicolon token'); $closer = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$closer]['scope_opener'], ($token + 5), 'Closer scope opener is not the arrow token'); $this->assertSame($tokens[$closer]['scope_closer'], ($token + 14), 'Closer scope closer is not the semicolon token'); }//end testYield() /** * Test arrow functions that use nullable namespace types. * * @covers PHP_CodeSniffer\Tokenizers\PHP::processAdditional * * @return void */ public function testNullableNamespace() { $tokens = self::$phpcsFile->getTokens(); $token = $this->getTargetToken('/* testNullableNamespace */', T_FN); $this->backfillHelper($token); $this->assertSame($tokens[$token]['scope_opener'], ($token + 15), 'Scope opener is not the arrow token'); $this->assertSame($tokens[$token]['scope_closer'], ($token + 18), 'Scope closer is not the semicolon token'); $opener = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$opener]['scope_opener'], ($token + 15), 'Opener scope opener is not the arrow token'); $this->assertSame($tokens[$opener]['scope_closer'], ($token + 18), 'Opener scope closer is not the semicolon token'); $closer = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$closer]['scope_opener'], ($token + 15), 'Closer scope opener is not the arrow token'); $this->assertSame($tokens[$closer]['scope_closer'], ($token + 18), 'Closer scope closer is not the semicolon token'); }//end testNullableNamespace() /** * Test arrow functions that use self/parent/callable return types. * * @covers PHP_CodeSniffer\Tokenizers\PHP::processAdditional * * @return void */ public function testKeywordReturnTypes() { $tokens = self::$phpcsFile->getTokens(); $testMarkers = [ 'Self', 'Parent', 'Callable', 'Array', ]; foreach ($testMarkers as $marker) { $token = $this->getTargetToken('/* test'.$marker.'ReturnType */', T_FN); $this->backfillHelper($token); $this->assertSame($tokens[$token]['scope_opener'], ($token + 11), "Scope opener is not the arrow token (for $marker)"); $this->assertSame($tokens[$token]['scope_closer'], ($token + 14), "Scope closer is not the semicolon token(for $marker)"); $opener = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$opener]['scope_opener'], ($token + 11), "Opener scope opener is not the arrow token(for $marker)"); $this->assertSame($tokens[$opener]['scope_closer'], ($token + 14), "Opener scope closer is not the semicolon token(for $marker)"); $closer = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$closer]['scope_opener'], ($token + 11), "Closer scope opener is not the arrow token(for $marker)"); $this->assertSame($tokens[$closer]['scope_closer'], ($token + 14), "Closer scope closer is not the semicolon token(for $marker)"); } }//end testKeywordReturnTypes() /** * Test arrow functions used in ternary operators. * * @covers PHP_CodeSniffer\Tokenizers\PHP::processAdditional * * @return void */ public function testTernary() { $tokens = self::$phpcsFile->getTokens(); $token = $this->getTargetToken('/* testTernary */', T_FN); $this->backfillHelper($token); $this->assertSame($tokens[$token]['scope_opener'], ($token + 5), 'Scope opener is not the arrow token'); $this->assertSame($tokens[$token]['scope_closer'], ($token + 40), 'Scope closer is not the semicolon token'); $opener = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$opener]['scope_opener'], ($token + 5), 'Opener scope opener is not the arrow token'); $this->assertSame($tokens[$opener]['scope_closer'], ($token + 40), 'Opener scope closer is not the semicolon token'); $closer = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$closer]['scope_opener'], ($token + 5), 'Closer scope opener is not the arrow token'); $this->assertSame($tokens[$closer]['scope_closer'], ($token + 40), 'Closer scope closer is not the semicolon token'); $token = $this->getTargetToken('/* testTernaryThen */', T_FN); $this->backfillHelper($token); $this->assertSame($tokens[$token]['scope_opener'], ($token + 8), 'Scope opener for THEN is not the arrow token'); $this->assertSame($tokens[$token]['scope_closer'], ($token + 12), 'Scope closer for THEN is not the semicolon token'); $opener = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$opener]['scope_opener'], ($token + 8), 'Opener scope opener for THEN is not the arrow token'); $this->assertSame($tokens[$opener]['scope_closer'], ($token + 12), 'Opener scope closer for THEN is not the semicolon token'); $closer = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$closer]['scope_opener'], ($token + 8), 'Closer scope opener for THEN is not the arrow token'); $this->assertSame($tokens[$closer]['scope_closer'], ($token + 12), 'Closer scope closer for THEN is not the semicolon token'); $token = $this->getTargetToken('/* testTernaryElse */', T_FN); $this->backfillHelper($token); $this->assertSame($tokens[$token]['scope_opener'], ($token + 8), 'Scope opener for ELSE is not the arrow token'); $this->assertSame($tokens[$token]['scope_closer'], ($token + 11), 'Scope closer for ELSE is not the semicolon token'); $opener = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$opener]['scope_opener'], ($token + 8), 'Opener scope opener for ELSE is not the arrow token'); $this->assertSame($tokens[$opener]['scope_closer'], ($token + 11), 'Opener scope closer for ELSE is not the semicolon token'); $closer = $tokens[$token]['scope_opener']; $this->assertSame($tokens[$closer]['scope_opener'], ($token + 8), 'Closer scope opener for ELSE is not the arrow token'); $this->assertSame($tokens[$closer]['scope_closer'], ($token + 11), 'Closer scope closer for ELSE is not the semicolon token'); }//end testTernary() /** * Test that the backfill presumes T_FN during live coding, but doesn't set the additional index keys. * * @covers PHP_CodeSniffer\Tokenizers\PHP::processAdditional * * @return void */ public function testLiveCoding() { $tokens = self::$phpcsFile->getTokens(); $token = $this->getTargetToken('/* testLiveCoding */', [T_STRING, T_FN]); $this->assertSame($tokens[$token]['code'], T_FN, 'Token not tokenized as T_FN'); $this->assertArrayNotHasKey('scope_condition', $tokens[$token], 'Scope condition is set'); $this->assertArrayNotHasKey('scope_opener', $tokens[$token], 'Scope opener is set'); $this->assertArrayNotHasKey('scope_closer', $tokens[$token], 'Scope closer is set'); $this->assertArrayNotHasKey('parenthesis_owner', $tokens[$token], 'Parenthesis owner is set'); $this->assertArrayNotHasKey('parenthesis_opener', $tokens[$token], 'Parenthesis opener is set'); $this->assertArrayNotHasKey('parenthesis_closer', $tokens[$token], 'Parenthesis closer is set'); }//end testLiveCoding() /** * Helper function to check that all token keys are correctly set for T_FN tokens. * * @param string $token The T_FN token to check. * * @return void */ private function backfillHelper($token) { $tokens = self::$phpcsFile->getTokens(); $this->assertTrue(array_key_exists('scope_condition', $tokens[$token]), 'Scope condition is not set'); $this->assertTrue(array_key_exists('scope_opener', $tokens[$token]), 'Scope opener is not set'); $this->assertTrue(array_key_exists('scope_closer', $tokens[$token]), 'Scope closer is not set'); $this->assertSame($tokens[$token]['scope_condition'], $token, 'Scope condition is not the T_FN token'); $this->assertTrue(array_key_exists('parenthesis_owner', $tokens[$token]), 'Parenthesis owner is not set'); $this->assertTrue(array_key_exists('parenthesis_opener', $tokens[$token]), 'Parenthesis opener is not set'); $this->assertTrue(array_key_exists('parenthesis_closer', $tokens[$token]), 'Parenthesis closer is not set'); $this->assertSame($tokens[$token]['parenthesis_owner'], $token, 'Parenthesis owner is not the T_FN token'); $opener = $tokens[$token]['scope_opener']; $this->assertTrue(array_key_exists('scope_condition', $tokens[$opener]), 'Opener scope condition is not set'); $this->assertTrue(array_key_exists('scope_opener', $tokens[$opener]), 'Opener scope opener is not set'); $this->assertTrue(array_key_exists('scope_closer', $tokens[$opener]), 'Opener scope closer is not set'); $this->assertSame($tokens[$opener]['scope_condition'], $token, 'Opener scope condition is not the T_FN token'); $closer = $tokens[$token]['scope_opener']; $this->assertTrue(array_key_exists('scope_condition', $tokens[$closer]), 'Closer scope condition is not set'); $this->assertTrue(array_key_exists('scope_opener', $tokens[$closer]), 'Closer scope opener is not set'); $this->assertTrue(array_key_exists('scope_closer', $tokens[$closer]), 'Closer scope closer is not set'); $this->assertSame($tokens[$closer]['scope_condition'], $token, 'Closer scope condition is not the T_FN token'); $opener = $tokens[$token]['parenthesis_opener']; $this->assertTrue(array_key_exists('parenthesis_owner', $tokens[$opener]), 'Opening parenthesis owner is not set'); $this->assertSame($tokens[$opener]['parenthesis_owner'], $token, 'Opening parenthesis owner is not the T_FN token'); $closer = $tokens[$token]['parenthesis_closer']; $this->assertTrue(array_key_exists('parenthesis_owner', $tokens[$closer]), 'Closing parenthesis owner is not set'); $this->assertSame($tokens[$closer]['parenthesis_owner'], $token, 'Closing parenthesis owner is not the T_FN token'); }//end backfillHelper() }//end class PHP_CodeSniffer-3.5.4/tests/Core/Tokenizer/BackfillNumericSeparatorTest.inc0000644000076500000240000000244513614652361026573 0ustar gsherwoodstaff * @copyright 2019 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests\Core\Tokenizer; use PHP_CodeSniffer\Tests\Core\AbstractMethodUnitTest; class BackfillNumericSeparatorTest extends AbstractMethodUnitTest { /** * Test that numbers using numeric seperators are tokenized correctly. * * @param array $testData The data required for the specific test case. * * @dataProvider dataTestBackfill * @covers PHP_CodeSniffer\Tokenizers\PHP::tokenize * * @return void */ public function testBackfill($testData) { $tokens = self::$phpcsFile->getTokens(); $number = $this->getTargetToken($testData['marker'], [T_LNUMBER, T_DNUMBER]); $this->assertSame(constant($testData['type']), $tokens[$number]['code']); $this->assertSame($testData['type'], $tokens[$number]['type']); $this->assertSame($testData['value'], $tokens[$number]['content']); }//end testBackfill() /** * Data provider. * * @see testBackfill() * * @return array */ public function dataTestBackfill() { $testHexType = 'T_LNUMBER'; if (PHP_INT_MAX < 0xCAFEF00D) { $testHexType = 'T_DNUMBER'; } $testHexMultipleType = 'T_LNUMBER'; if (PHP_INT_MAX < 0x42726F776E) { $testHexMultipleType = 'T_DNUMBER'; } $testIntMoreThanMaxType = 'T_LNUMBER'; if (PHP_INT_MAX < 10223372036854775807) { $testIntMoreThanMaxType = 'T_DNUMBER'; } return [ [ [ 'marker' => '/* testSimpleLNumber */', 'type' => 'T_LNUMBER', 'value' => '1_000_000_000', ], ], [ [ 'marker' => '/* testSimpleDNumber */', 'type' => 'T_DNUMBER', 'value' => '107_925_284.88', ], ], [ [ 'marker' => '/* testFloat */', 'type' => 'T_DNUMBER', 'value' => '6.674_083e-11', ], ], [ [ 'marker' => '/* testFloat2 */', 'type' => 'T_DNUMBER', 'value' => '6.674_083e+11', ], ], [ [ 'marker' => '/* testFloat3 */', 'type' => 'T_DNUMBER', 'value' => '1_2.3_4e1_23', ], ], [ [ 'marker' => '/* testHex */', 'type' => $testHexType, 'value' => '0xCAFE_F00D', ], ], [ [ 'marker' => '/* testHexMultiple */', 'type' => $testHexMultipleType, 'value' => '0x42_72_6F_77_6E', ], ], [ [ 'marker' => '/* testHexInt */', 'type' => 'T_LNUMBER', 'value' => '0x42_72_6F', ], ], [ [ 'marker' => '/* testBinary */', 'type' => 'T_LNUMBER', 'value' => '0b0101_1111', ], ], [ [ 'marker' => '/* testOctal */', 'type' => 'T_LNUMBER', 'value' => '0137_041', ], ], [ [ 'marker' => '/* testIntMoreThanMax */', 'type' => $testIntMoreThanMaxType, 'value' => '10_223_372_036_854_775_807', ], ], ]; }//end dataTestBackfill() /** * Test that numbers using numeric seperators which are considered parse errors and/or * which aren't relevant to the backfill, do not incorrectly trigger the backfill anyway. * * @param string $testMarker The comment which prefaces the target token in the test file. * @param array $expectedTokens The token type and content of the expected token sequence. * * @dataProvider dataNoBackfill * @covers PHP_CodeSniffer\Tokenizers\PHP::tokenize * * @return void */ public function testNoBackfill($testMarker, $expectedTokens) { $tokens = self::$phpcsFile->getTokens(); $number = $this->getTargetToken($testMarker, [T_LNUMBER, T_DNUMBER]); foreach ($expectedTokens as $key => $expectedToken) { $i = ($number + $key); $this->assertSame($expectedToken['code'], $tokens[$i]['code']); $this->assertSame($expectedToken['content'], $tokens[$i]['content']); } }//end testNoBackfill() /** * Data provider. * * @see testBackfill() * * @return array */ public function dataNoBackfill() { return [ [ '/* testInvalid1 */', [ [ 'code' => T_LNUMBER, 'content' => '100', ], [ 'code' => T_STRING, 'content' => '_', ], ], ], [ '/* testInvalid2 */', [ [ 'code' => T_LNUMBER, 'content' => '1', ], [ 'code' => T_STRING, 'content' => '__1', ], ], ], [ '/* testInvalid3 */', [ [ 'code' => T_LNUMBER, 'content' => '1', ], [ 'code' => T_STRING, 'content' => '_', ], [ 'code' => T_DNUMBER, 'content' => '.0', ], ], ], [ '/* testInvalid4 */', [ [ 'code' => T_DNUMBER, 'content' => '1.', ], [ 'code' => T_STRING, 'content' => '_0', ], ], ], [ '/* testInvalid5 */', [ [ 'code' => T_LNUMBER, 'content' => '0', ], [ 'code' => T_STRING, 'content' => 'x_123', ], ], ], [ '/* testInvalid6 */', [ [ 'code' => T_LNUMBER, 'content' => '0', ], [ 'code' => T_STRING, 'content' => 'b_101', ], ], ], [ '/* testInvalid7 */', [ [ 'code' => T_LNUMBER, 'content' => '1', ], [ 'code' => T_STRING, 'content' => '_e2', ], ], ], [ '/* testInvalid8 */', [ [ 'code' => T_LNUMBER, 'content' => '1', ], [ 'code' => T_STRING, 'content' => 'e_2', ], ], ], [ '/* testInvalid9 */', [ [ 'code' => T_LNUMBER, 'content' => '107_925_284', ], [ 'code' => T_WHITESPACE, 'content' => ' ', ], [ 'code' => T_DNUMBER, 'content' => '.88', ], ], ], [ '/* testInvalid10 */', [ [ 'code' => T_LNUMBER, 'content' => '107_925_284', ], [ 'code' => T_COMMENT, 'content' => '/*comment*/', ], [ 'code' => T_DNUMBER, 'content' => '.88', ], ], ], [ '/* testCalc1 */', [ [ 'code' => T_LNUMBER, 'content' => '667_083', ], [ 'code' => T_WHITESPACE, 'content' => ' ', ], [ 'code' => T_MINUS, 'content' => '-', ], [ 'code' => T_WHITESPACE, 'content' => ' ', ], [ 'code' => T_LNUMBER, 'content' => '11', ], ], ], [ '/* test Calc2 */', [ [ 'code' => T_DNUMBER, 'content' => '6.674_08e3', ], [ 'code' => T_WHITESPACE, 'content' => ' ', ], [ 'code' => T_PLUS, 'content' => '+', ], [ 'code' => T_WHITESPACE, 'content' => ' ', ], [ 'code' => T_LNUMBER, 'content' => '11', ], ], ], ]; }//end dataNoBackfill() }//end class PHP_CodeSniffer-3.5.4/tests/Core/AbstractMethodUnitTest.php0000644000076500000240000001026213614652361023464 0ustar gsherwoodstaff * @copyright 2018-2019 Juliette Reinders Folmer. All rights reserved. * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests\Core; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Ruleset; use PHP_CodeSniffer\Files\DummyFile; use PHPUnit\Framework\TestCase; abstract class AbstractMethodUnitTest extends TestCase { /** * The file extension of the test case file (without leading dot). * * This allows child classes to overrule the default `inc` with, for instance, * `js` or `css` when applicable. * * @var string */ protected static $fileExtension = 'inc'; /** * The \PHP_CodeSniffer\Files\File object containing the parsed contents of the test case file. * * @var \PHP_CodeSniffer\Files\File */ protected static $phpcsFile; /** * Initialize & tokenize \PHP_CodeSniffer\Files\File with code from the test case file. * * The test case file for a unit test class has to be in the same directory * directory and use the same file name as the test class, using the .inc extension. * * @return void */ public static function setUpBeforeClass() { $config = new Config(); $config->standards = ['PSR1']; $ruleset = new Ruleset($config); // Default to a file with the same name as the test class. Extension is property based. $relativeCN = str_replace(__NAMESPACE__, '', get_called_class()); $relativePath = str_replace('\\', DIRECTORY_SEPARATOR, $relativeCN); $pathToTestFile = realpath(__DIR__).$relativePath.'.'.static::$fileExtension; // Make sure the file gets parsed correctly based on the file type. $contents = 'phpcs_input_file: '.$pathToTestFile.PHP_EOL; $contents .= file_get_contents($pathToTestFile); self::$phpcsFile = new DummyFile($contents, $ruleset, $config); self::$phpcsFile->process(); }//end setUpBeforeClass() /** * Clean up after finished test. * * @return void */ public static function tearDownAfterClass() { self::$phpcsFile = null; }//end tearDownAfterClass() /** * Get the token pointer for a target token based on a specific comment found on the line before. * * Note: the test delimiter comment MUST start with "/* test" to allow this function to * distinguish between comments used *in* a test and test delimiters. * * @param string $commentString The delimiter comment to look for. * @param int|string|array $tokenType The type of token(s) to look for. * @param string $tokenContent Optional. The token content for the target token. * * @return int */ public function getTargetToken($commentString, $tokenType, $tokenContent=null) { $start = (self::$phpcsFile->numTokens - 1); $comment = self::$phpcsFile->findPrevious( T_COMMENT, $start, null, false, $commentString ); $tokens = self::$phpcsFile->getTokens(); $end = ($start + 1); // Limit the token finding to between this and the next delimiter comment. for ($i = ($comment + 1); $i < $end; $i++) { if ($tokens[$i]['code'] !== T_COMMENT) { continue; } if (stripos($tokens[$i]['content'], '/* test') === 0) { $end = $i; break; } } $target = self::$phpcsFile->findNext( $tokenType, ($comment + 1), $end, false, $tokenContent ); if ($target === false) { $msg = 'Failed to find test target token for comment string: '.$commentString; if ($tokenContent !== null) { $msg .= ' With token content: '.$tokenContent; } $this->assertFalse(true, $msg); } return $target; }//end getTargetToken() }//end class PHP_CodeSniffer-3.5.4/tests/Core/AllTests.php0000644000076500000240000000272213614652361020615 0ustar gsherwoodstaff * @author Juliette Reinders Folmer * @copyright 2006-2019 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests\Core; use PHP_CodeSniffer\Tests\FileList; use PHPUnit\TextUI\TestRunner; use PHPUnit\Framework\TestSuite; class AllTests { /** * Prepare the test runner. * * @return void */ public static function main() { TestRunner::run(self::suite()); }//end main() /** * Add all core unit tests into a test suite. * * @return \PHPUnit\Framework\TestSuite */ public static function suite() { $suite = new TestSuite('PHP CodeSniffer Core'); $testFileIterator = new FileList(__DIR__, '', '`Test\.php$`Di'); foreach ($testFileIterator->fileIterator as $file) { if (strpos($file, 'AbstractMethodUnitTest.php') !== false) { continue; } include_once $file; $class = str_replace(__DIR__, '', $file); $class = str_replace('.php', '', $class); $class = str_replace('/', '\\', $class); $class = 'PHP_CodeSniffer\Tests\Core'.$class; $suite->addTestSuite($class); } return $suite; }//end suite() }//end class PHP_CodeSniffer-3.5.4/tests/Core/ErrorSuppressionTest.php0000644000076500000240000015071413614652361023273 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests\Core; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Ruleset; use PHP_CodeSniffer\Files\DummyFile; use PHPUnit\Framework\TestCase; class ErrorSuppressionTest extends TestCase { /** * Test suppressing a single error. * * @return void */ public function testSuppressError() { $config = new Config(); $config->standards = ['Generic']; $config->sniffs = ['Generic.PHP.LowerCaseConstant']; $ruleset = new Ruleset($config); // Process without suppression. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); // Process with inline comment suppression. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); // Process with multi-line inline comment suppression, tab-indented. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); // Process with inline @ comment suppression. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); // Process with inline comment suppression mixed case. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); // Process with inline comment suppression (deprecated syntax). $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); // Process with block comment suppression. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); // Process with multi-line block comment suppression. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); // Process with multi-line block comment suppression, each line starred. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); // Process with multi-line block comment suppression, tab-indented. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); // Process with block comment suppression (deprecated syntax). $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); // Process with multi-line block comment suppression (deprecated syntax). $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); // Process with a docblock suppression. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); // Process with a docblock suppression (deprecated syntax). $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); }//end testSuppressError() /** * Test suppressing 1 out of 2 errors. * * @return void */ public function testSuppressSomeErrors() { $config = new Config(); $config->standards = ['Generic']; $config->sniffs = ['Generic.PHP.LowerCaseConstant']; $ruleset = new Ruleset($config); // Process without suppression. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(2, $numErrors); $this->assertCount(2, $errors); // Process with suppression. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); // Process with @ suppression. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); // Process with suppression (deprecated syntax). $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); // Process with a PHPDoc block suppression. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); // Process with a PHPDoc block suppression (deprecated syntax). $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); }//end testSuppressSomeErrors() /** * Test suppressing a single warning. * * @return void */ public function testSuppressWarning() { $config = new Config(); $config->standards = ['Generic']; $config->sniffs = ['Generic.Commenting.Todo']; $ruleset = new Ruleset($config); // Process without suppression. $content = 'process(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(1, $numWarnings); $this->assertCount(1, $warnings); // Process with suppression. $content = 'process(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); // Process with @ suppression. $content = 'process(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); // Process with suppression (deprecated syntax). $content = 'process(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); // Process with a docblock suppression. $content = 'process(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); // Process with a docblock suppression (deprecated syntax). $content = 'process(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); }//end testSuppressWarning() /** * Test suppressing a single error using a single line ignore. * * @return void */ public function testSuppressLine() { $config = new Config(); $config->standards = ['Generic']; $config->sniffs = ['Generic.PHP.LowerCaseConstant']; $ruleset = new Ruleset($config); // Process without suppression. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(2, $numErrors); $this->assertCount(2, $errors); // Process with suppression on line before. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); // Process with @ suppression on line before. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); // Process with suppression on line before. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); // Process with @ suppression on line before. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); // Process with suppression on line before (deprecated syntax). $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); // Process with suppression on same line. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); // Process with @ suppression on same line. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); // Process with suppression on same line (deprecated syntax). $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); }//end testSuppressLine() /** * Test that using a single line ignore does not interfere with other suppressions. * * @return void */ public function testNestedSuppressLine() { $config = new Config(); $config->standards = ['Generic']; $config->sniffs = ['Generic.PHP.LowerCaseConstant']; $ruleset = new Ruleset($config); // Process with disable/enable suppression and no single line suppression. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); // Process with disable/enable @ suppression and no single line suppression. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); // Process with disable/enable suppression and no single line suppression (deprecated syntax). $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); // Process with line suppression nested within disable/enable suppression. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); // Process with line @ suppression nested within disable/enable @ suppression. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); // Process with line suppression nested within disable/enable suppression (deprecated syntax). $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); }//end testNestedSuppressLine() /** * Test suppressing a scope opener. * * @return void */ public function testSuppressScope() { $config = new Config(); $config->standards = ['PEAR']; $config->sniffs = ['PEAR.NamingConventions.ValidVariableName']; $ruleset = new Ruleset($config); // Process without suppression. $content = 'foo();'.PHP_EOL.'}'.PHP_EOL.'}'; $file = new DummyFile($content, $ruleset, $config); $file->process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); // Process with suppression. $content = 'foo();'.PHP_EOL.'}'.PHP_EOL.'}'; $file = new DummyFile($content, $ruleset, $config); $file->process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); // Process with suppression. $content = 'foo();'.PHP_EOL.'}'.PHP_EOL.'}'; $file = new DummyFile($content, $ruleset, $config); $file->process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); // Process with suppression (deprecated syntax). $content = 'foo();'.PHP_EOL.'}'.PHP_EOL.'}'; $file = new DummyFile($content, $ruleset, $config); $file->process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); // Process with a docblock suppression. $content = 'foo();'.PHP_EOL.'}'.PHP_EOL.'}'; $file = new DummyFile($content, $ruleset, $config); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); // Process with a docblock @ suppression. $content = 'foo();'.PHP_EOL.'}'.PHP_EOL.'}'; $file = new DummyFile($content, $ruleset, $config); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); // Process with a docblock suppression (deprecated syntax). $content = 'foo();'.PHP_EOL.'}'.PHP_EOL.'}'; $file = new DummyFile($content, $ruleset, $config); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); }//end testSuppressScope() /** * Test suppressing a whole file. * * @return void */ public function testSuppressFile() { $config = new Config(); $config->standards = ['Generic']; $config->sniffs = ['Generic.Commenting.Todo']; $ruleset = new Ruleset($config); // Process without suppression. $content = 'process(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(1, $numWarnings); $this->assertCount(1, $warnings); // Process with suppression. $content = 'process(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); // Process with @ suppression. $content = 'process(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); // Process with suppression (deprecated syntax). $content = 'process(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); // Process mixed case. $content = 'process(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); // Process late comment. $content = 'process(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); // Process late comment (deprecated syntax). $content = 'process(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); // Process with a block comment suppression. $content = 'process(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); // Process with a multi-line block comment suppression. $content = 'process(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); // Process with a block comment suppression (deprecated syntax). $content = 'process(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); // Process with a multi-line block comment suppression (deprecated syntax). $content = 'process(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); // Process with docblock suppression. $content = 'process(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); // Process with docblock suppression (deprecated syntax). $content = 'process(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); }//end testSuppressFile() /** * Test disabling specific sniffs. * * @return void */ public function testDisableSelected() { $config = new Config(); $config->standards = ['Generic']; $config->sniffs = [ 'Generic.PHP.LowerCaseConstant', 'Generic.Commenting.Todo', ]; $ruleset = new Ruleset($config); // Suppress a single sniff. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); // Suppress multiple sniffs. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); // Suppress adding sniffs. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); // Suppress a category of sniffs. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); // Suppress a whole standard. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); // Suppress using docblocks. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); // Suppress wrong category using docblocks. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); $this->assertEquals(1, $numWarnings); $this->assertCount(1, $warnings); $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); $this->assertEquals(1, $numWarnings); $this->assertCount(1, $warnings); }//end testDisableSelected() /** * Test re-enabling specific sniffs that have been disabled. * * @return void */ public function testEnableSelected() { $config = new Config(); $config->standards = ['Generic']; $config->sniffs = [ 'Generic.PHP.LowerCaseConstant', 'Generic.Commenting.Todo', ]; $ruleset = new Ruleset($config); // Suppress a single sniff and re-enable. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); $this->assertEquals(1, $numWarnings); $this->assertCount(1, $warnings); // Suppress multiple sniffs and re-enable. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); $this->assertEquals(1, $numWarnings); $this->assertCount(1, $warnings); // Suppress multiple sniffs and re-enable one. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); $this->assertEquals(1, $numWarnings); $this->assertCount(1, $warnings); // Suppress a category of sniffs and re-enable. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); $this->assertEquals(1, $numWarnings); $this->assertCount(1, $warnings); // Suppress a whole standard and re-enable. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); $this->assertEquals(1, $numWarnings); $this->assertCount(1, $warnings); // Suppress a whole standard and re-enable a category. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); $this->assertEquals(1, $numWarnings); $this->assertCount(1, $warnings); // Suppress a category and re-enable a whole standard. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); $this->assertEquals(1, $numWarnings); $this->assertCount(1, $warnings); // Suppress a sniff and re-enable a category. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); $this->assertEquals(1, $numWarnings); $this->assertCount(1, $warnings); // Suppress a whole standard and re-enable a sniff. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); $this->assertEquals(1, $numWarnings); $this->assertCount(1, $warnings); // Suppress a whole standard and re-enable and re-disable a sniff. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); $this->assertEquals(2, $numWarnings); $this->assertCount(2, $warnings); // Suppress a whole standard and re-enable 2 specific sniffs independently. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); $this->assertEquals(2, $numWarnings); $this->assertCount(2, $warnings); }//end testEnableSelected() /** * Test ignoring specific sniffs. * * @return void */ public function testIgnoreSelected() { $config = new Config(); $config->standards = ['Generic']; $config->sniffs = [ 'Generic.PHP.LowerCaseConstant', 'Generic.Commenting.Todo', ]; $ruleset = new Ruleset($config); // No suppression. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(2, $numErrors); $this->assertCount(2, $errors); $this->assertEquals(2, $numWarnings); $this->assertCount(2, $warnings); // Suppress a single sniff. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(2, $numErrors); $this->assertCount(2, $errors); $this->assertEquals(1, $numWarnings); $this->assertCount(1, $warnings); // Suppress multiple sniffs. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); $this->assertEquals(1, $numWarnings); $this->assertCount(1, $warnings); // Add to suppression. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); // Suppress a category of sniffs. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(2, $numErrors); $this->assertCount(2, $errors); $this->assertEquals(1, $numWarnings); $this->assertCount(1, $warnings); // Suppress a whole standard. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); $this->assertEquals(1, $numWarnings); $this->assertCount(1, $warnings); }//end testIgnoreSelected() /** * Test ignoring specific sniffs. * * @return void */ public function testCommenting() { $config = new Config(); $config->standards = ['Generic']; $config->sniffs = [ 'Generic.PHP.LowerCaseConstant', 'Generic.Commenting.Todo', ]; $ruleset = new Ruleset($config); // Suppress a single sniff. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(2, $numErrors); $this->assertCount(2, $errors); $this->assertEquals(1, $numWarnings); $this->assertCount(1, $warnings); // Suppress a single sniff and re-enable. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); $this->assertEquals(1, $numWarnings); $this->assertCount(1, $warnings); // Suppress a single sniff using block comments. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(1, $numErrors); $this->assertCount(1, $errors); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); // Suppress a single sniff with a multi-line comment. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(2, $numErrors); $this->assertCount(2, $errors); $this->assertEquals(1, $numWarnings); $this->assertCount(1, $warnings); // Ignore an enable before a disable. $content = 'process(); $errors = $file->getErrors(); $numErrors = $file->getErrorCount(); $warnings = $file->getWarnings(); $numWarnings = $file->getWarningCount(); $this->assertEquals(0, $numErrors); $this->assertCount(0, $errors); $this->assertEquals(0, $numWarnings); $this->assertCount(0, $warnings); }//end testCommenting() }//end class PHP_CodeSniffer-3.5.4/tests/Core/IsCamelCapsTest.php0000644000076500000240000001120213614652361022037 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests\Core; use PHP_CodeSniffer\Util\Common; use PHPUnit\Framework\TestCase; class IsCamelCapsTest extends TestCase { /** * Test valid public function/method names. * * @return void */ public function testValidNotClassFormatPublic() { $this->assertTrue(Common::isCamelCaps('thisIsCamelCaps', false, true, true)); $this->assertTrue(Common::isCamelCaps('thisISCamelCaps', false, true, false)); }//end testValidNotClassFormatPublic() /** * Test invalid public function/method names. * * @return void */ public function testInvalidNotClassFormatPublic() { $this->assertFalse(Common::isCamelCaps('_thisIsCamelCaps', false, true, true)); $this->assertFalse(Common::isCamelCaps('thisISCamelCaps', false, true, true)); $this->assertFalse(Common::isCamelCaps('ThisIsCamelCaps', false, true, true)); $this->assertFalse(Common::isCamelCaps('3thisIsCamelCaps', false, true, true)); $this->assertFalse(Common::isCamelCaps('*thisIsCamelCaps', false, true, true)); $this->assertFalse(Common::isCamelCaps('-thisIsCamelCaps', false, true, true)); $this->assertFalse(Common::isCamelCaps('this*IsCamelCaps', false, true, true)); $this->assertFalse(Common::isCamelCaps('this-IsCamelCaps', false, true, true)); $this->assertFalse(Common::isCamelCaps('this_IsCamelCaps', false, true, true)); $this->assertFalse(Common::isCamelCaps('this_is_camel_caps', false, true, true)); }//end testInvalidNotClassFormatPublic() /** * Test valid private method names. * * @return void */ public function testValidNotClassFormatPrivate() { $this->assertTrue(Common::isCamelCaps('_thisIsCamelCaps', false, false, true)); $this->assertTrue(Common::isCamelCaps('_thisISCamelCaps', false, false, false)); $this->assertTrue(Common::isCamelCaps('_i18N', false, false, true)); $this->assertTrue(Common::isCamelCaps('_i18n', false, false, true)); }//end testValidNotClassFormatPrivate() /** * Test invalid private method names. * * @return void */ public function testInvalidNotClassFormatPrivate() { $this->assertFalse(Common::isCamelCaps('thisIsCamelCaps', false, false, true)); $this->assertFalse(Common::isCamelCaps('_thisISCamelCaps', false, false, true)); $this->assertFalse(Common::isCamelCaps('_ThisIsCamelCaps', false, false, true)); $this->assertFalse(Common::isCamelCaps('__thisIsCamelCaps', false, false, true)); $this->assertFalse(Common::isCamelCaps('__thisISCamelCaps', false, false, false)); $this->assertFalse(Common::isCamelCaps('3thisIsCamelCaps', false, false, true)); $this->assertFalse(Common::isCamelCaps('*thisIsCamelCaps', false, false, true)); $this->assertFalse(Common::isCamelCaps('-thisIsCamelCaps', false, false, true)); $this->assertFalse(Common::isCamelCaps('_this_is_camel_caps', false, false, true)); }//end testInvalidNotClassFormatPrivate() /** * Test valid class names. * * @return void */ public function testValidClassFormatPublic() { $this->assertTrue(Common::isCamelCaps('ThisIsCamelCaps', true, true, true)); $this->assertTrue(Common::isCamelCaps('ThisISCamelCaps', true, true, false)); $this->assertTrue(Common::isCamelCaps('This3IsCamelCaps', true, true, false)); }//end testValidClassFormatPublic() /** * Test invalid class names. * * @return void */ public function testInvalidClassFormat() { $this->assertFalse(Common::isCamelCaps('thisIsCamelCaps', true)); $this->assertFalse(Common::isCamelCaps('This-IsCamelCaps', true)); $this->assertFalse(Common::isCamelCaps('This_Is_Camel_Caps', true)); }//end testInvalidClassFormat() /** * Test invalid class names with the private flag set. * * Note that the private flag is ignored if the class format * flag is set, so these names are all invalid. * * @return void */ public function testInvalidClassFormatPrivate() { $this->assertFalse(Common::isCamelCaps('_ThisIsCamelCaps', true, true)); $this->assertFalse(Common::isCamelCaps('_ThisIsCamelCaps', true, false)); }//end testInvalidClassFormatPrivate() }//end class PHP_CodeSniffer-3.5.4/tests/Standards/AbstractSniffUnitTest.php0000644000076500000240000003656313614652361024360 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests\Standards; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Exceptions\RuntimeException; use PHP_CodeSniffer\Ruleset; use PHP_CodeSniffer\Files\LocalFile; use PHP_CodeSniffer\Util\Common; use PHPUnit\Framework\TestCase; abstract class AbstractSniffUnitTest extends TestCase { /** * Enable or disable the backup and restoration of the $GLOBALS array. * Overwrite this attribute in a child class of TestCase. * Setting this attribute in setUp() has no effect! * * @var boolean */ protected $backupGlobals = false; /** * The path to the standard's main directory. * * @var string */ public $standardsDir = null; /** * The path to the standard's test directory. * * @var string */ public $testsDir = null; /** * Sets up this unit test. * * @return void */ protected function setUp() { $class = get_class($this); $this->standardsDir = $GLOBALS['PHP_CODESNIFFER_STANDARD_DIRS'][$class]; $this->testsDir = $GLOBALS['PHP_CODESNIFFER_TEST_DIRS'][$class]; }//end setUp() /** * Get a list of all test files to check. * * These will have the same base as the sniff name but different extensions. * We ignore the .php file as it is the class. * * @param string $testFileBase The base path that the unit tests files will have. * * @return string[] */ protected function getTestFiles($testFileBase) { $testFiles = []; $dir = substr($testFileBase, 0, strrpos($testFileBase, DIRECTORY_SEPARATOR)); $di = new \DirectoryIterator($dir); foreach ($di as $file) { $path = $file->getPathname(); if (substr($path, 0, strlen($testFileBase)) === $testFileBase) { if ($path !== $testFileBase.'php' && substr($path, -5) !== 'fixed' && substr($path, -4) !== '.bak') { $testFiles[] = $path; } } } // Put them in order. sort($testFiles); return $testFiles; }//end getTestFiles() /** * Should this test be skipped for some reason. * * @return boolean */ protected function shouldSkipTest() { return false; }//end shouldSkipTest() /** * Tests the extending classes Sniff class. * * @return void * @throws \PHPUnit\Framework\Exception */ final public function testSniff() { // Skip this test if we can't run in this environment. if ($this->shouldSkipTest() === true) { $this->markTestSkipped(); } $sniffCode = Common::getSniffCode(get_class($this)); list($standardName, $categoryName, $sniffName) = explode('.', $sniffCode); $testFileBase = $this->testsDir.$categoryName.DIRECTORY_SEPARATOR.$sniffName.'UnitTest.'; // Get a list of all test files to check. $testFiles = $this->getTestFiles($testFileBase); $GLOBALS['PHP_CODESNIFFER_SNIFF_CASE_FILES'][] = $testFiles; if (isset($GLOBALS['PHP_CODESNIFFER_CONFIG']) === true) { $config = $GLOBALS['PHP_CODESNIFFER_CONFIG']; } else { $config = new Config(); $config->cache = false; $GLOBALS['PHP_CODESNIFFER_CONFIG'] = $config; } $config->standards = [$standardName]; $config->sniffs = [$sniffCode]; $config->ignored = []; if (isset($GLOBALS['PHP_CODESNIFFER_RULESETS']) === false) { $GLOBALS['PHP_CODESNIFFER_RULESETS'] = []; } if (isset($GLOBALS['PHP_CODESNIFFER_RULESETS'][$standardName]) === false) { $ruleset = new Ruleset($config); $GLOBALS['PHP_CODESNIFFER_RULESETS'][$standardName] = $ruleset; } $ruleset = $GLOBALS['PHP_CODESNIFFER_RULESETS'][$standardName]; $sniffFile = $this->standardsDir.DIRECTORY_SEPARATOR.'Sniffs'.DIRECTORY_SEPARATOR.$categoryName.DIRECTORY_SEPARATOR.$sniffName.'Sniff.php'; $sniffClassName = substr(get_class($this), 0, -8).'Sniff'; $sniffClassName = str_replace('\Tests\\', '\Sniffs\\', $sniffClassName); $sniffClassName = Common::cleanSniffClass($sniffClassName); $restrictions = [strtolower($sniffClassName) => true]; $ruleset->registerSniffs([$sniffFile], $restrictions, []); $ruleset->populateTokenListeners(); $failureMessages = []; foreach ($testFiles as $testFile) { $filename = basename($testFile); $oldConfig = $config->getSettings(); try { $this->setCliValues($filename, $config); $phpcsFile = new LocalFile($testFile, $ruleset, $config); $phpcsFile->process(); } catch (RuntimeException $e) { $this->fail('An unexpected exception has been caught: '.$e->getMessage()); } $failures = $this->generateFailureMessages($phpcsFile); $failureMessages = array_merge($failureMessages, $failures); if ($phpcsFile->getFixableCount() > 0) { // Attempt to fix the errors. $phpcsFile->fixer->fixFile(); $fixable = $phpcsFile->getFixableCount(); if ($fixable > 0) { $failureMessages[] = "Failed to fix $fixable fixable violations in $filename"; } // Check for a .fixed file to check for accuracy of fixes. $fixedFile = $testFile.'.fixed'; if (file_exists($fixedFile) === true) { $diff = $phpcsFile->fixer->generateDiff($fixedFile); if (trim($diff) !== '') { $filename = basename($testFile); $fixedFilename = basename($fixedFile); $failureMessages[] = "Fixed version of $filename does not match expected version in $fixedFilename; the diff is\n$diff"; } } } // Restore the config. $config->setSettings($oldConfig); }//end foreach if (empty($failureMessages) === false) { $this->fail(implode(PHP_EOL, $failureMessages)); } }//end testSniff() /** * Generate a list of test failures for a given sniffed file. * * @param \PHP_CodeSniffer\Files\LocalFile $file The file being tested. * * @return array * @throws \PHP_CodeSniffer\Exceptions\RuntimeException */ public function generateFailureMessages(LocalFile $file) { $testFile = $file->getFilename(); $foundErrors = $file->getErrors(); $foundWarnings = $file->getWarnings(); $expectedErrors = $this->getErrorList(basename($testFile)); $expectedWarnings = $this->getWarningList(basename($testFile)); if (is_array($expectedErrors) === false) { throw new RuntimeException('getErrorList() must return an array'); } if (is_array($expectedWarnings) === false) { throw new RuntimeException('getWarningList() must return an array'); } /* We merge errors and warnings together to make it easier to iterate over them and produce the errors string. In this way, we can report on errors and warnings in the same line even though it's not really structured to allow that. */ $allProblems = []; $failureMessages = []; foreach ($foundErrors as $line => $lineErrors) { foreach ($lineErrors as $column => $errors) { if (isset($allProblems[$line]) === false) { $allProblems[$line] = [ 'expected_errors' => 0, 'expected_warnings' => 0, 'found_errors' => [], 'found_warnings' => [], ]; } $foundErrorsTemp = []; foreach ($allProblems[$line]['found_errors'] as $foundError) { $foundErrorsTemp[] = $foundError; } $errorsTemp = []; foreach ($errors as $foundError) { $errorsTemp[] = $foundError['message'].' ('.$foundError['source'].')'; $source = $foundError['source']; if (in_array($source, $GLOBALS['PHP_CODESNIFFER_SNIFF_CODES'], true) === false) { $GLOBALS['PHP_CODESNIFFER_SNIFF_CODES'][] = $source; } if ($foundError['fixable'] === true && in_array($source, $GLOBALS['PHP_CODESNIFFER_FIXABLE_CODES'], true) === false ) { $GLOBALS['PHP_CODESNIFFER_FIXABLE_CODES'][] = $source; } } $allProblems[$line]['found_errors'] = array_merge($foundErrorsTemp, $errorsTemp); }//end foreach if (isset($expectedErrors[$line]) === true) { $allProblems[$line]['expected_errors'] = $expectedErrors[$line]; } else { $allProblems[$line]['expected_errors'] = 0; } unset($expectedErrors[$line]); }//end foreach foreach ($expectedErrors as $line => $numErrors) { if (isset($allProblems[$line]) === false) { $allProblems[$line] = [ 'expected_errors' => 0, 'expected_warnings' => 0, 'found_errors' => [], 'found_warnings' => [], ]; } $allProblems[$line]['expected_errors'] = $numErrors; } foreach ($foundWarnings as $line => $lineWarnings) { foreach ($lineWarnings as $column => $warnings) { if (isset($allProblems[$line]) === false) { $allProblems[$line] = [ 'expected_errors' => 0, 'expected_warnings' => 0, 'found_errors' => [], 'found_warnings' => [], ]; } $foundWarningsTemp = []; foreach ($allProblems[$line]['found_warnings'] as $foundWarning) { $foundWarningsTemp[] = $foundWarning; } $warningsTemp = []; foreach ($warnings as $warning) { $warningsTemp[] = $warning['message'].' ('.$warning['source'].')'; } $allProblems[$line]['found_warnings'] = array_merge($foundWarningsTemp, $warningsTemp); }//end foreach if (isset($expectedWarnings[$line]) === true) { $allProblems[$line]['expected_warnings'] = $expectedWarnings[$line]; } else { $allProblems[$line]['expected_warnings'] = 0; } unset($expectedWarnings[$line]); }//end foreach foreach ($expectedWarnings as $line => $numWarnings) { if (isset($allProblems[$line]) === false) { $allProblems[$line] = [ 'expected_errors' => 0, 'expected_warnings' => 0, 'found_errors' => [], 'found_warnings' => [], ]; } $allProblems[$line]['expected_warnings'] = $numWarnings; } // Order the messages by line number. ksort($allProblems); foreach ($allProblems as $line => $problems) { $numErrors = count($problems['found_errors']); $numWarnings = count($problems['found_warnings']); $expectedErrors = $problems['expected_errors']; $expectedWarnings = $problems['expected_warnings']; $errors = ''; $foundString = ''; if ($expectedErrors !== $numErrors || $expectedWarnings !== $numWarnings) { $lineMessage = "[LINE $line]"; $expectedMessage = 'Expected '; $foundMessage = 'in '.basename($testFile).' but found '; if ($expectedErrors !== $numErrors) { $expectedMessage .= "$expectedErrors error(s)"; $foundMessage .= "$numErrors error(s)"; if ($numErrors !== 0) { $foundString .= 'error(s)'; $errors .= implode(PHP_EOL.' -> ', $problems['found_errors']); } if ($expectedWarnings !== $numWarnings) { $expectedMessage .= ' and '; $foundMessage .= ' and '; if ($numWarnings !== 0) { if ($foundString !== '') { $foundString .= ' and '; } } } } if ($expectedWarnings !== $numWarnings) { $expectedMessage .= "$expectedWarnings warning(s)"; $foundMessage .= "$numWarnings warning(s)"; if ($numWarnings !== 0) { $foundString .= 'warning(s)'; if (empty($errors) === false) { $errors .= PHP_EOL.' -> '; } $errors .= implode(PHP_EOL.' -> ', $problems['found_warnings']); } } $fullMessage = "$lineMessage $expectedMessage $foundMessage."; if ($errors !== '') { $fullMessage .= " The $foundString found were:".PHP_EOL." -> $errors"; } $failureMessages[] = $fullMessage; }//end if }//end foreach return $failureMessages; }//end generateFailureMessages() /** * Get a list of CLI values to set before the file is tested. * * @param string $filename The name of the file being tested. * @param \PHP_CodeSniffer\Config $config The config data for the run. * * @return void */ public function setCliValues($filename, $config) { return; }//end setCliValues() /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ abstract protected function getErrorList(); /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ abstract protected function getWarningList(); }//end class PHP_CodeSniffer-3.5.4/tests/Standards/AllSniffs.php0000644000076500000240000000743613614652361022005 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests\Standards; use PHP_CodeSniffer\Util\Standards; use PHP_CodeSniffer\Autoload; use PHPUnit\TextUI\TestRunner; use PHPUnit\Framework\TestSuite; class AllSniffs { /** * Prepare the test runner. * * @return void */ public static function main() { TestRunner::run(self::suite()); }//end main() /** * Add all sniff unit tests into a test suite. * * Sniff unit tests are found by recursing through the 'Tests' directory * of each installed coding standard. * * @return \PHPUnit\Framework\TestSuite */ public static function suite() { $GLOBALS['PHP_CODESNIFFER_SNIFF_CODES'] = []; $GLOBALS['PHP_CODESNIFFER_FIXABLE_CODES'] = []; $GLOBALS['PHP_CODESNIFFER_SNIFF_CASE_FILES'] = []; $suite = new TestSuite('PHP CodeSniffer Standards'); $isInstalled = !is_file(__DIR__.'/../../autoload.php'); // Optionally allow for ignoring the tests for one or more standards. $ignoreTestsForStandards = getenv('PHPCS_IGNORE_TESTS'); if ($ignoreTestsForStandards === false) { $ignoreTestsForStandards = []; } else { $ignoreTestsForStandards = explode(',', $ignoreTestsForStandards); } $installedStandards = self::getInstalledStandardDetails(); foreach ($installedStandards as $standard => $details) { Autoload::addSearchPath($details['path'], $details['namespace']); // If the test is running PEAR installed, the built-in standards // are split into different directories; one for the sniffs and // a different file system location for tests. if ($isInstalled === true && is_dir(dirname($details['path']).DIRECTORY_SEPARATOR.'Generic') === true) { $testPath = realpath(__DIR__.'/../../src/Standards/'.$standard); } else { $testPath = $details['path']; } if (in_array($standard, $ignoreTestsForStandards, true) === true) { continue; } $testsDir = $testPath.DIRECTORY_SEPARATOR.'Tests'.DIRECTORY_SEPARATOR; if (is_dir($testsDir) === false) { // No tests for this standard. continue; } $di = new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($testsDir)); foreach ($di as $file) { // Skip hidden files. if (substr($file->getFilename(), 0, 1) === '.') { continue; } // Tests must have the extension 'php'. $parts = explode('.', $file); $ext = array_pop($parts); if ($ext !== 'php') { continue; } $className = Autoload::loadFile($file->getPathname()); $GLOBALS['PHP_CODESNIFFER_STANDARD_DIRS'][$className] = $details['path']; $GLOBALS['PHP_CODESNIFFER_TEST_DIRS'][$className] = $testsDir; $suite->addTestSuite($className); } }//end foreach return $suite; }//end suite() /** * Get the details of all coding standards installed. * * @return array * @see Standards::getInstalledStandardDetails() */ protected static function getInstalledStandardDetails() { return Standards::getInstalledStandardDetails(true); }//end getInstalledStandardDetails() }//end class PHP_CodeSniffer-3.5.4/tests/AllTests.php0000644000076500000240000000341313614652361017723 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests; $GLOBALS['PHP_CODESNIFFER_PEAR'] = false; if (is_file(__DIR__.'/../autoload.php') === true) { include_once 'Core/AllTests.php'; include_once 'Standards/AllSniffs.php'; } else { include_once 'CodeSniffer/Core/AllTests.php'; include_once 'CodeSniffer/Standards/AllSniffs.php'; include_once 'FileList.php'; $GLOBALS['PHP_CODESNIFFER_PEAR'] = true; } // PHPUnit 7 made the TestSuite run() method incompatible with // older PHPUnit versions due to return type hints, so maintain // two different suite objects. $phpunit7 = false; if (class_exists('\PHPUnit\Runner\Version') === true) { $version = \PHPUnit\Runner\Version::id(); if ($version[0] === '7') { $phpunit7 = true; } } if ($phpunit7 === true) { include_once 'TestSuite7.php'; } else { include_once 'TestSuite.php'; } class PHP_CodeSniffer_AllTests { /** * Add all PHP_CodeSniffer test suites into a single test suite. * * @return \PHPUnit\Framework\TestSuite */ public static function suite() { $GLOBALS['PHP_CODESNIFFER_STANDARD_DIRS'] = []; $GLOBALS['PHP_CODESNIFFER_TEST_DIRS'] = []; // Use a special PHP_CodeSniffer test suite so that we can // unset our autoload function after the run. $suite = new TestSuite('PHP CodeSniffer'); $suite->addTest(Core\AllTests::suite()); $suite->addTest(Standards\AllSniffs::suite()); return $suite; }//end suite() }//end class PHP_CodeSniffer-3.5.4/tests/bootstrap.php0000644000076500000240000000512613614652361020210 0ustar gsherwoodstaff * @copyright 2006-2017 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ if (defined('PHP_CODESNIFFER_IN_TESTS') === false) { define('PHP_CODESNIFFER_IN_TESTS', true); } if (defined('PHP_CODESNIFFER_CBF') === false) { define('PHP_CODESNIFFER_CBF', false); } if (defined('PHP_CODESNIFFER_VERBOSITY') === false) { define('PHP_CODESNIFFER_VERBOSITY', 0); } if (is_file(__DIR__.'/../autoload.php') === true) { include_once __DIR__.'/../autoload.php'; } else { include_once 'PHP/CodeSniffer/autoload.php'; } $tokens = new \PHP_CodeSniffer\Util\Tokens(); // Compatibility for PHPUnit < 6 and PHPUnit 6+. if (class_exists('PHPUnit_Framework_TestSuite') === true && class_exists('PHPUnit\Framework\TestSuite') === false) { class_alias('PHPUnit_Framework_TestSuite', 'PHPUnit'.'\Framework\TestSuite'); } if (class_exists('PHPUnit_Framework_TestCase') === true && class_exists('PHPUnit\Framework\TestCase') === false) { class_alias('PHPUnit_Framework_TestCase', 'PHPUnit'.'\Framework\TestCase'); } if (class_exists('PHPUnit_TextUI_TestRunner') === true && class_exists('PHPUnit\TextUI\TestRunner') === false) { class_alias('PHPUnit_TextUI_TestRunner', 'PHPUnit'.'\TextUI\TestRunner'); } if (class_exists('PHPUnit_Framework_TestResult') === true && class_exists('PHPUnit\Framework\TestResult') === false) { class_alias('PHPUnit_Framework_TestResult', 'PHPUnit'.'\Framework\TestResult'); } /** * A global util function to help print unit test fixing data. * * @return void */ function printPHPCodeSnifferTestOutput() { echo PHP_EOL.PHP_EOL; $output = 'The test files'; $data = []; $codeCount = count($GLOBALS['PHP_CODESNIFFER_SNIFF_CODES']); if (empty($GLOBALS['PHP_CODESNIFFER_SNIFF_CASE_FILES']) === false) { $files = call_user_func_array('array_merge', $GLOBALS['PHP_CODESNIFFER_SNIFF_CASE_FILES']); $files = array_unique($files); $fileCount = count($files); $output = '%d sniff test files'; $data[] = $fileCount; } $output .= ' generated %d unique error codes'; $data[] = $codeCount; if ($codeCount > 0) { $fixes = count($GLOBALS['PHP_CODESNIFFER_FIXABLE_CODES']); $percent = round(($fixes / $codeCount * 100), 2); $output .= '; %d were fixable (%d%%)'; $data[] = $fixes; $data[] = $percent; } vprintf($output, $data); }//end printPHPCodeSnifferTestOutput() PHP_CodeSniffer-3.5.4/tests/FileList.php0000644000076500000240000000444313614652361017707 0ustar gsherwoodstaff * @copyright 2019 Juliette Reinders Folmer. All rights reserved. * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests; class FileList { /** * The path to the project root directory. * * @var string */ protected $rootPath; /** * Recursive directory iterator. * * @var \DirectoryIterator */ public $fileIterator; /** * Base regex to use if no filter regex is provided. * * Matches based on: * - File path starts with the project root (replacement done in constructor). * - Don't match .git/ files. * - Don't match dot files, i.e. "." or "..". * - Don't match backup files. * - Match everything else in a case-insensitive manner. * * @var string */ private $baseRegex = '`^%s(?!\.git/)(?!(.*/)?\.+$)(?!.*\.(bak|orig)).*$`Dix'; /** * Constructor. * * @param string $directory The directory to examine. * @param string $rootPath Path to the project root. * @param string $filter PCRE regular expression to filter the file list with. */ public function __construct($directory, $rootPath='', $filter='') { $this->rootPath = $rootPath; $directory = new \RecursiveDirectoryIterator( $directory, \RecursiveDirectoryIterator::UNIX_PATHS ); $flattened = new \RecursiveIteratorIterator( $directory, \RecursiveIteratorIterator::LEAVES_ONLY, \RecursiveIteratorIterator::CATCH_GET_CHILD ); if ($filter === '') { $filter = sprintf($this->baseRegex, preg_quote($this->rootPath)); } $this->fileIterator = new \RegexIterator($flattened, $filter); return $this; }//end __construct() /** * Retrieve the filtered file list as an array. * * @return array */ public function getList() { $fileList = []; foreach ($this->fileIterator as $file) { $fileList[] = str_replace($this->rootPath, '', $file); } return $fileList; }//end getList() }//end class PHP_CodeSniffer-3.5.4/tests/TestSuite.php0000644000076500000240000000151513614652361020122 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests; use PHPUnit\Framework\TestSuite as PHPUnit_TestSuite; use PHPUnit\Framework\TestResult; class TestSuite extends PHPUnit_TestSuite { /** * Runs the tests and collects their result in a TestResult. * * @param \PHPUnit\Framework\TestResult $result A test result. * * @return \PHPUnit\Framework\TestResult */ public function run(TestResult $result=null) { $result = parent::run($result); printPHPCodeSnifferTestOutput(); return $result; }//end run() }//end class PHP_CodeSniffer-3.5.4/tests/TestSuite7.php0000644000076500000240000000153113614652361020207 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tests; use PHPUnit\Framework\TestSuite as PHPUnit_TestSuite; use PHPUnit\Framework\TestResult; class TestSuite extends PHPUnit_TestSuite { /** * Runs the tests and collects their result in a TestResult. * * @param \PHPUnit\Framework\TestResult $result A test result. * * @return \PHPUnit\Framework\TestResult */ public function run(TestResult $result=null): TestResult { $result = parent::run($result); printPHPCodeSnifferTestOutput(); return $result; }//end run() }//end class PHP_CodeSniffer-3.5.4/src/Exceptions/DeepExitException.php0000644000076500000240000000102513614652361023321 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Exceptions; class DeepExitException extends \Exception { }//end class PHP_CodeSniffer-3.5.4/src/Exceptions/RuntimeException.php0000644000076500000240000000063313614652361023241 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Exceptions; class RuntimeException extends \RuntimeException { }//end class PHP_CodeSniffer-3.5.4/src/Exceptions/TokenizerException.php0000644000076500000240000000064013614652361023566 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Exceptions; class TokenizerException extends \Exception { }//end class PHP_CodeSniffer-3.5.4/src/Files/DummyFile.php0000644000076500000240000000515213614652361020554 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Files; use PHP_CodeSniffer\Ruleset; use PHP_CodeSniffer\Config; class DummyFile extends File { /** * Creates a DummyFile object and sets the content. * * @param string $content The content of the file. * @param \PHP_CodeSniffer\Ruleset $ruleset The ruleset used for the run. * @param \PHP_CodeSniffer\Config $config The config data for the run. * * @return void */ public function __construct($content, Ruleset $ruleset, Config $config) { $this->setContent($content); // See if a filename was defined in the content. // This is done by including: phpcs_input_file: [file path] // as the first line of content. $path = 'STDIN'; if ($content !== null) { if (substr($content, 0, 17) === 'phpcs_input_file:') { $eolPos = strpos($content, $this->eolChar); $filename = trim(substr($content, 17, ($eolPos - 17))); $content = substr($content, ($eolPos + strlen($this->eolChar))); $path = $filename; $this->setContent($content); } } // The CLI arg overrides anything passed in the content. if ($config->stdinPath !== null) { $path = $config->stdinPath; } parent::__construct($path, $ruleset, $config); }//end __construct() /** * Set the error, warning, and fixable counts for the file. * * @param int $errorCount The number of errors found. * @param int $warningCount The number of warnings found. * @param int $fixableCount The number of fixable errors found. * @param int $fixedCount The number of errors that were fixed. * * @return void */ public function setErrorCounts($errorCount, $warningCount, $fixableCount, $fixedCount) { $this->errorCount = $errorCount; $this->warningCount = $warningCount; $this->fixableCount = $fixableCount; $this->fixedCount = $fixedCount; }//end setErrorCounts() }//end class PHP_CodeSniffer-3.5.4/src/Files/File.php0000644000076500000240000026341613614652361017551 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Files; use PHP_CodeSniffer\Ruleset; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Fixer; use PHP_CodeSniffer\Util; use PHP_CodeSniffer\Exceptions\RuntimeException; use PHP_CodeSniffer\Exceptions\TokenizerException; class File { /** * The absolute path to the file associated with this object. * * @var string */ public $path = ''; /** * The content of the file. * * @var string */ protected $content = ''; /** * The config data for the run. * * @var \PHP_CodeSniffer\Config */ public $config = null; /** * The ruleset used for the run. * * @var \PHP_CodeSniffer\Ruleset */ public $ruleset = null; /** * If TRUE, the entire file is being ignored. * * @var boolean */ public $ignored = false; /** * The EOL character this file uses. * * @var string */ public $eolChar = ''; /** * The Fixer object to control fixing errors. * * @var \PHP_CodeSniffer\Fixer */ public $fixer = null; /** * The tokenizer being used for this file. * * @var \PHP_CodeSniffer\Tokenizers\Tokenizer */ public $tokenizer = null; /** * The name of the tokenizer being used for this file. * * @var string */ public $tokenizerType = 'PHP'; /** * Was the file loaded from cache? * * If TRUE, the file was loaded from a local cache. * If FALSE, the file was tokenized and processed fully. * * @var boolean */ public $fromCache = false; /** * The number of tokens in this file. * * Stored here to save calling count() everywhere. * * @var integer */ public $numTokens = 0; /** * The tokens stack map. * * @var array */ protected $tokens = []; /** * The errors raised from sniffs. * * @var array * @see getErrors() */ protected $errors = []; /** * The warnings raised from sniffs. * * @var array * @see getWarnings() */ protected $warnings = []; /** * The metrics recorded by sniffs. * * @var array * @see getMetrics() */ protected $metrics = []; /** * The metrics recorded for each token. * * Stops the same metric being recorded for the same token twice. * * @var array * @see getMetrics() */ private $metricTokens = []; /** * The total number of errors raised. * * @var integer */ protected $errorCount = 0; /** * The total number of warnings raised. * * @var integer */ protected $warningCount = 0; /** * The total number of errors and warnings that can be fixed. * * @var integer */ protected $fixableCount = 0; /** * The total number of errors and warnings that were fixed. * * @var integer */ protected $fixedCount = 0; /** * TRUE if errors are being replayed from the cache. * * @var boolean */ protected $replayingErrors = false; /** * An array of sniffs that are being ignored. * * @var array */ protected $ignoredListeners = []; /** * An array of message codes that are being ignored. * * @var array */ protected $ignoredCodes = []; /** * An array of sniffs listening to this file's processing. * * @var \PHP_CodeSniffer\Sniffs\Sniff[] */ protected $listeners = []; /** * The class name of the sniff currently processing the file. * * @var string */ protected $activeListener = ''; /** * An array of sniffs being processed and how long they took. * * @var array */ protected $listenerTimes = []; /** * A cache of often used config settings to improve performance. * * Storing them here saves 10k+ calls to __get() in the Config class. * * @var array */ protected $configCache = []; /** * Constructs a file. * * @param string $path The absolute path to the file to process. * @param \PHP_CodeSniffer\Ruleset $ruleset The ruleset used for the run. * @param \PHP_CodeSniffer\Config $config The config data for the run. * * @return void */ public function __construct($path, Ruleset $ruleset, Config $config) { $this->path = $path; $this->ruleset = $ruleset; $this->config = $config; $this->fixer = new Fixer(); $parts = explode('.', $path); $extension = array_pop($parts); if (isset($config->extensions[$extension]) === true) { $this->tokenizerType = $config->extensions[$extension]; } else { // Revert to default. $this->tokenizerType = 'PHP'; } $this->configCache['cache'] = $this->config->cache; $this->configCache['sniffs'] = array_map('strtolower', $this->config->sniffs); $this->configCache['exclude'] = array_map('strtolower', $this->config->exclude); $this->configCache['errorSeverity'] = $this->config->errorSeverity; $this->configCache['warningSeverity'] = $this->config->warningSeverity; $this->configCache['recordErrors'] = $this->config->recordErrors; $this->configCache['ignorePatterns'] = $this->ruleset->ignorePatterns; $this->configCache['includePatterns'] = $this->ruleset->includePatterns; }//end __construct() /** * Set the content of the file. * * Setting the content also calculates the EOL char being used. * * @param string $content The file content. * * @return void */ public function setContent($content) { $this->content = $content; $this->tokens = []; try { $this->eolChar = Util\Common::detectLineEndings($content); } catch (RuntimeException $e) { $this->addWarningOnLine($e->getMessage(), 1, 'Internal.DetectLineEndings'); return; } }//end setContent() /** * Reloads the content of the file. * * By default, we have no idea where our content comes from, * so we can't do anything. * * @return void */ public function reloadContent() { }//end reloadContent() /** * Disables caching of this file. * * @return void */ public function disableCaching() { $this->configCache['cache'] = false; }//end disableCaching() /** * Starts the stack traversal and tells listeners when tokens are found. * * @return void */ public function process() { if ($this->ignored === true) { return; } $this->errors = []; $this->warnings = []; $this->errorCount = 0; $this->warningCount = 0; $this->fixableCount = 0; $this->parse(); // Check if tokenizer errors cause this file to be ignored. if ($this->ignored === true) { return; } $this->fixer->startFile($this); if (PHP_CODESNIFFER_VERBOSITY > 2) { echo "\t*** START TOKEN PROCESSING ***".PHP_EOL; } $foundCode = false; $listenerIgnoreTo = []; $inTests = defined('PHP_CODESNIFFER_IN_TESTS'); $checkAnnotations = $this->config->annotations; // Foreach of the listeners that have registered to listen for this // token, get them to process it. foreach ($this->tokens as $stackPtr => $token) { // Check for ignored lines. if ($checkAnnotations === true && ($token['code'] === T_COMMENT || $token['code'] === T_PHPCS_IGNORE_FILE || $token['code'] === T_PHPCS_SET || $token['code'] === T_DOC_COMMENT_STRING || $token['code'] === T_DOC_COMMENT_TAG || ($inTests === true && $token['code'] === T_INLINE_HTML)) ) { $commentText = ltrim($this->tokens[$stackPtr]['content'], ' /*'); $commentTextLower = strtolower($commentText); if (strpos($commentText, '@codingStandards') !== false) { if (strpos($commentText, '@codingStandardsIgnoreFile') !== false) { // Ignoring the whole file, just a little late. $this->errors = []; $this->warnings = []; $this->errorCount = 0; $this->warningCount = 0; $this->fixableCount = 0; return; } else if (strpos($commentText, '@codingStandardsChangeSetting') !== false) { $start = strpos($commentText, '@codingStandardsChangeSetting'); $comment = substr($commentText, ($start + 30)); $parts = explode(' ', $comment); if (count($parts) >= 2) { $sniffParts = explode('.', $parts[0]); if (count($sniffParts) >= 3) { // If the sniff code is not known to us, it has not been registered in this run. // But don't throw an error as it could be there for a different standard to use. if (isset($this->ruleset->sniffCodes[$parts[0]]) === true) { $listenerCode = array_shift($parts); $propertyCode = array_shift($parts); $propertyValue = rtrim(implode(' ', $parts), " */\r\n"); $listenerClass = $this->ruleset->sniffCodes[$listenerCode]; $this->ruleset->setSniffProperty($listenerClass, $propertyCode, $propertyValue); } } } }//end if } else if (substr($commentTextLower, 0, 16) === 'phpcs:ignorefile' || substr($commentTextLower, 0, 17) === '@phpcs:ignorefile' ) { // Ignoring the whole file, just a little late. $this->errors = []; $this->warnings = []; $this->errorCount = 0; $this->warningCount = 0; $this->fixableCount = 0; return; } else if (substr($commentTextLower, 0, 9) === 'phpcs:set' || substr($commentTextLower, 0, 10) === '@phpcs:set' ) { if (isset($token['sniffCode']) === true) { $listenerCode = $token['sniffCode']; if (isset($this->ruleset->sniffCodes[$listenerCode]) === true) { $propertyCode = $token['sniffProperty']; $propertyValue = $token['sniffPropertyValue']; $listenerClass = $this->ruleset->sniffCodes[$listenerCode]; $this->ruleset->setSniffProperty($listenerClass, $propertyCode, $propertyValue); } } }//end if }//end if if (PHP_CODESNIFFER_VERBOSITY > 2) { $type = $token['type']; $content = Util\Common::prepareForOutput($token['content']); echo "\t\tProcess token $stackPtr: $type => $content".PHP_EOL; } if ($token['code'] !== T_INLINE_HTML) { $foundCode = true; } if (isset($this->ruleset->tokenListeners[$token['code']]) === false) { continue; } foreach ($this->ruleset->tokenListeners[$token['code']] as $listenerData) { if (isset($this->ignoredListeners[$listenerData['class']]) === true || (isset($listenerIgnoreTo[$listenerData['class']]) === true && $listenerIgnoreTo[$listenerData['class']] > $stackPtr) ) { // This sniff is ignoring past this token, or the whole file. continue; } // Make sure this sniff supports the tokenizer // we are currently using. $class = $listenerData['class']; if (isset($listenerData['tokenizers'][$this->tokenizerType]) === false) { continue; } // If the file path matches one of our ignore patterns, skip it. // While there is support for a type of each pattern // (absolute or relative) we don't actually support it here. foreach ($listenerData['ignore'] as $pattern) { // We assume a / directory separator, as do the exclude rules // most developers write, so we need a special case for any system // that is different. if (DIRECTORY_SEPARATOR === '\\') { $pattern = str_replace('/', '\\\\', $pattern); } $pattern = '`'.$pattern.'`i'; if (preg_match($pattern, $this->path) === 1) { $this->ignoredListeners[$class] = true; continue(2); } } // If the file path does not match one of our include patterns, skip it. // While there is support for a type of each pattern // (absolute or relative) we don't actually support it here. if (empty($listenerData['include']) === false) { $included = false; foreach ($listenerData['include'] as $pattern) { // We assume a / directory separator, as do the exclude rules // most developers write, so we need a special case for any system // that is different. if (DIRECTORY_SEPARATOR === '\\') { $pattern = str_replace('/', '\\\\', $pattern); } $pattern = '`'.$pattern.'`i'; if (preg_match($pattern, $this->path) === 1) { $included = true; break; } } if ($included === false) { $this->ignoredListeners[$class] = true; continue; } }//end if $this->activeListener = $class; if (PHP_CODESNIFFER_VERBOSITY > 2) { $startTime = microtime(true); echo "\t\t\tProcessing ".$this->activeListener.'... '; } $ignoreTo = $this->ruleset->sniffs[$class]->process($this, $stackPtr); if ($ignoreTo !== null) { $listenerIgnoreTo[$this->activeListener] = $ignoreTo; } if (PHP_CODESNIFFER_VERBOSITY > 2) { $timeTaken = (microtime(true) - $startTime); if (isset($this->listenerTimes[$this->activeListener]) === false) { $this->listenerTimes[$this->activeListener] = 0; } $this->listenerTimes[$this->activeListener] += $timeTaken; $timeTaken = round(($timeTaken), 4); echo "DONE in $timeTaken seconds".PHP_EOL; } $this->activeListener = ''; }//end foreach }//end foreach // If short open tags are off but the file being checked uses // short open tags, the whole content will be inline HTML // and nothing will be checked. So try and handle this case. // We don't show this error for STDIN because we can't be sure the content // actually came directly from the user. It could be something like // refs from a Git pre-push hook. if ($foundCode === false && $this->tokenizerType === 'PHP' && $this->path !== 'STDIN') { $shortTags = (bool) ini_get('short_open_tag'); if ($shortTags === false) { $error = 'No PHP code was found in this file and short open tags are not allowed by this install of PHP. This file may be using short open tags but PHP does not allow them.'; $this->addWarning($error, null, 'Internal.NoCodeFound'); } } if (PHP_CODESNIFFER_VERBOSITY > 2) { echo "\t*** END TOKEN PROCESSING ***".PHP_EOL; echo "\t*** START SNIFF PROCESSING REPORT ***".PHP_EOL; asort($this->listenerTimes, SORT_NUMERIC); $this->listenerTimes = array_reverse($this->listenerTimes, true); foreach ($this->listenerTimes as $listener => $timeTaken) { echo "\t$listener: ".round(($timeTaken), 4).' secs'.PHP_EOL; } echo "\t*** END SNIFF PROCESSING REPORT ***".PHP_EOL; } $this->fixedCount += $this->fixer->getFixCount(); }//end process() /** * Tokenizes the file and prepares it for the test run. * * @return void */ public function parse() { if (empty($this->tokens) === false) { // File has already been parsed. return; } try { $tokenizerClass = 'PHP_CodeSniffer\Tokenizers\\'.$this->tokenizerType; $this->tokenizer = new $tokenizerClass($this->content, $this->config, $this->eolChar); $this->tokens = $this->tokenizer->getTokens(); } catch (TokenizerException $e) { $this->ignored = true; $this->addWarning($e->getMessage(), null, 'Internal.Tokenizer.Exception'); if (PHP_CODESNIFFER_VERBOSITY > 0) { echo "[$this->tokenizerType => tokenizer error]... "; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo PHP_EOL; } } return; } $this->numTokens = count($this->tokens); // Check for mixed line endings as these can cause tokenizer errors and we // should let the user know that the results they get may be incorrect. // This is done by removing all backslashes, removing the newline char we // detected, then converting newlines chars into text. If any backslashes // are left at the end, we have additional newline chars in use. $contents = str_replace('\\', '', $this->content); $contents = str_replace($this->eolChar, '', $contents); $contents = str_replace("\n", '\n', $contents); $contents = str_replace("\r", '\r', $contents); if (strpos($contents, '\\') !== false) { $error = 'File has mixed line endings; this may cause incorrect results'; $this->addWarningOnLine($error, 1, 'Internal.LineEndings.Mixed'); } if (PHP_CODESNIFFER_VERBOSITY > 0) { if ($this->numTokens === 0) { $numLines = 0; } else { $numLines = $this->tokens[($this->numTokens - 1)]['line']; } echo "[$this->tokenizerType => $this->numTokens tokens in $numLines lines]... "; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo PHP_EOL; } } }//end parse() /** * Returns the token stack for this file. * * @return array */ public function getTokens() { return $this->tokens; }//end getTokens() /** * Remove vars stored in this file that are no longer required. * * @return void */ public function cleanUp() { $this->listenerTimes = null; $this->content = null; $this->tokens = null; $this->metricTokens = null; $this->tokenizer = null; $this->fixer = null; $this->config = null; $this->ruleset = null; }//end cleanUp() /** * Records an error against a specific token in the file. * * @param string $error The error message. * @param int $stackPtr The stack position where the error occurred. * @param string $code A violation code unique to the sniff message. * @param array $data Replacements for the error message. * @param int $severity The severity level for this error. A value of 0 * will be converted into the default severity level. * @param boolean $fixable Can the error be fixed by the sniff? * * @return boolean */ public function addError( $error, $stackPtr, $code, $data=[], $severity=0, $fixable=false ) { if ($stackPtr === null) { $line = 1; $column = 1; } else { $line = $this->tokens[$stackPtr]['line']; $column = $this->tokens[$stackPtr]['column']; } return $this->addMessage(true, $error, $line, $column, $code, $data, $severity, $fixable); }//end addError() /** * Records a warning against a specific token in the file. * * @param string $warning The error message. * @param int $stackPtr The stack position where the error occurred. * @param string $code A violation code unique to the sniff message. * @param array $data Replacements for the warning message. * @param int $severity The severity level for this warning. A value of 0 * will be converted into the default severity level. * @param boolean $fixable Can the warning be fixed by the sniff? * * @return boolean */ public function addWarning( $warning, $stackPtr, $code, $data=[], $severity=0, $fixable=false ) { if ($stackPtr === null) { $line = 1; $column = 1; } else { $line = $this->tokens[$stackPtr]['line']; $column = $this->tokens[$stackPtr]['column']; } return $this->addMessage(false, $warning, $line, $column, $code, $data, $severity, $fixable); }//end addWarning() /** * Records an error against a specific line in the file. * * @param string $error The error message. * @param int $line The line on which the error occurred. * @param string $code A violation code unique to the sniff message. * @param array $data Replacements for the error message. * @param int $severity The severity level for this error. A value of 0 * will be converted into the default severity level. * * @return boolean */ public function addErrorOnLine( $error, $line, $code, $data=[], $severity=0 ) { return $this->addMessage(true, $error, $line, 1, $code, $data, $severity, false); }//end addErrorOnLine() /** * Records a warning against a specific token in the file. * * @param string $warning The error message. * @param int $line The line on which the warning occurred. * @param string $code A violation code unique to the sniff message. * @param array $data Replacements for the warning message. * @param int $severity The severity level for this warning. A value of 0 will * will be converted into the default severity level. * * @return boolean */ public function addWarningOnLine( $warning, $line, $code, $data=[], $severity=0 ) { return $this->addMessage(false, $warning, $line, 1, $code, $data, $severity, false); }//end addWarningOnLine() /** * Records a fixable error against a specific token in the file. * * Returns true if the error was recorded and should be fixed. * * @param string $error The error message. * @param int $stackPtr The stack position where the error occurred. * @param string $code A violation code unique to the sniff message. * @param array $data Replacements for the error message. * @param int $severity The severity level for this error. A value of 0 * will be converted into the default severity level. * * @return boolean */ public function addFixableError( $error, $stackPtr, $code, $data=[], $severity=0 ) { $recorded = $this->addError($error, $stackPtr, $code, $data, $severity, true); if ($recorded === true && $this->fixer->enabled === true) { return true; } return false; }//end addFixableError() /** * Records a fixable warning against a specific token in the file. * * Returns true if the warning was recorded and should be fixed. * * @param string $warning The error message. * @param int $stackPtr The stack position where the error occurred. * @param string $code A violation code unique to the sniff message. * @param array $data Replacements for the warning message. * @param int $severity The severity level for this warning. A value of 0 * will be converted into the default severity level. * * @return boolean */ public function addFixableWarning( $warning, $stackPtr, $code, $data=[], $severity=0 ) { $recorded = $this->addWarning($warning, $stackPtr, $code, $data, $severity, true); if ($recorded === true && $this->fixer->enabled === true) { return true; } return false; }//end addFixableWarning() /** * Adds an error to the error stack. * * @param boolean $error Is this an error message? * @param string $message The text of the message. * @param int $line The line on which the message occurred. * @param int $column The column at which the message occurred. * @param string $code A violation code unique to the sniff message. * @param array $data Replacements for the message. * @param int $severity The severity level for this message. A value of 0 * will be converted into the default severity level. * @param boolean $fixable Can the problem be fixed by the sniff? * * @return boolean */ protected function addMessage($error, $message, $line, $column, $code, $data, $severity, $fixable) { // Check if this line is ignoring all message codes. if (isset($this->tokenizer->ignoredLines[$line]['.all']) === true) { return false; } // Work out which sniff generated the message. $parts = explode('.', $code); if ($parts[0] === 'Internal') { // An internal message. $listenerCode = Util\Common::getSniffCode($this->activeListener); $sniffCode = $code; $checkCodes = [$sniffCode]; } else { if ($parts[0] !== $code) { // The full message code has been passed in. $sniffCode = $code; $listenerCode = substr($sniffCode, 0, strrpos($sniffCode, '.')); } else { $listenerCode = Util\Common::getSniffCode($this->activeListener); $sniffCode = $listenerCode.'.'.$code; $parts = explode('.', $sniffCode); } $checkCodes = [ $sniffCode, $parts[0].'.'.$parts[1].'.'.$parts[2], $parts[0].'.'.$parts[1], $parts[0], ]; }//end if if (isset($this->tokenizer->ignoredLines[$line]) === true) { // Check if this line is ignoring this specific message. $ignored = false; foreach ($checkCodes as $checkCode) { if (isset($this->tokenizer->ignoredLines[$line][$checkCode]) === true) { $ignored = true; break; } } // If it is ignored, make sure it's not whitelisted. if ($ignored === true && isset($this->tokenizer->ignoredLines[$line]['.except']) === true ) { foreach ($checkCodes as $checkCode) { if (isset($this->tokenizer->ignoredLines[$line]['.except'][$checkCode]) === true) { $ignored = false; break; } } } if ($ignored === true) { return false; } }//end if $includeAll = true; if ($this->configCache['cache'] === false || $this->configCache['recordErrors'] === false ) { $includeAll = false; } // Filter out any messages for sniffs that shouldn't have run // due to the use of the --sniffs command line argument. if ($includeAll === false && ((empty($this->configCache['sniffs']) === false && in_array(strtolower($listenerCode), $this->configCache['sniffs'], true) === false) || (empty($this->configCache['exclude']) === false && in_array(strtolower($listenerCode), $this->configCache['exclude'], true) === true)) ) { return false; } // If we know this sniff code is being ignored for this file, return early. foreach ($checkCodes as $checkCode) { if (isset($this->ignoredCodes[$checkCode]) === true) { return false; } } $oppositeType = 'warning'; if ($error === false) { $oppositeType = 'error'; } foreach ($checkCodes as $checkCode) { // Make sure this message type has not been set to the opposite message type. if (isset($this->ruleset->ruleset[$checkCode]['type']) === true && $this->ruleset->ruleset[$checkCode]['type'] === $oppositeType ) { $error = !$error; break; } } if ($error === true) { $configSeverity = $this->configCache['errorSeverity']; $messageCount = &$this->errorCount; $messages = &$this->errors; } else { $configSeverity = $this->configCache['warningSeverity']; $messageCount = &$this->warningCount; $messages = &$this->warnings; } if ($includeAll === false && $configSeverity === 0) { // Don't bother doing any processing as these messages are just going to // be hidden in the reports anyway. return false; } if ($severity === 0) { $severity = 5; } foreach ($checkCodes as $checkCode) { // Make sure we are interested in this severity level. if (isset($this->ruleset->ruleset[$checkCode]['severity']) === true) { $severity = $this->ruleset->ruleset[$checkCode]['severity']; break; } } if ($includeAll === false && $configSeverity > $severity) { return false; } // Make sure we are not ignoring this file. $included = null; foreach ($checkCodes as $checkCode) { $patterns = null; if (isset($this->configCache['includePatterns'][$checkCode]) === true) { $patterns = $this->configCache['includePatterns'][$checkCode]; $excluding = false; } else if (isset($this->configCache['ignorePatterns'][$checkCode]) === true) { $patterns = $this->configCache['ignorePatterns'][$checkCode]; $excluding = true; } if ($patterns === null) { continue; } foreach ($patterns as $pattern => $type) { // While there is support for a type of each pattern // (absolute or relative) we don't actually support it here. $replacements = [ '\\,' => ',', '*' => '.*', ]; // We assume a / directory separator, as do the exclude rules // most developers write, so we need a special case for any system // that is different. if (DIRECTORY_SEPARATOR === '\\') { $replacements['/'] = '\\\\'; } $pattern = '`'.strtr($pattern, $replacements).'`i'; $matched = preg_match($pattern, $this->path); if ($matched === 0) { if ($excluding === false && $included === null) { // This file path is not being included. $included = false; } continue; } if ($excluding === true) { // This file path is being excluded. $this->ignoredCodes[$checkCode] = true; return false; } // This file path is being included. $included = true; break; }//end foreach }//end foreach if ($included === false) { // There were include rules set, but this file // path didn't match any of them. return false; } $messageCount++; if ($fixable === true) { $this->fixableCount++; } if ($this->configCache['recordErrors'] === false && $includeAll === false ) { return true; } // See if there is a custom error message format to use. // But don't do this if we are replaying errors because replayed // errors have already used the custom format and have had their // data replaced. if ($this->replayingErrors === false && isset($this->ruleset->ruleset[$sniffCode]['message']) === true ) { $message = $this->ruleset->ruleset[$sniffCode]['message']; } if (empty($data) === false) { $message = vsprintf($message, $data); } if (isset($messages[$line]) === false) { $messages[$line] = []; } if (isset($messages[$line][$column]) === false) { $messages[$line][$column] = []; } $messages[$line][$column][] = [ 'message' => $message, 'source' => $sniffCode, 'listener' => $this->activeListener, 'severity' => $severity, 'fixable' => $fixable, ]; if (PHP_CODESNIFFER_VERBOSITY > 1 && $this->fixer->enabled === true && $fixable === true ) { @ob_end_clean(); echo "\tE: [Line $line] $message ($sniffCode)".PHP_EOL; ob_start(); } return true; }//end addMessage() /** * Record a metric about the file being examined. * * @param int $stackPtr The stack position where the metric was recorded. * @param string $metric The name of the metric being recorded. * @param string $value The value of the metric being recorded. * * @return boolean */ public function recordMetric($stackPtr, $metric, $value) { if (isset($this->metrics[$metric]) === false) { $this->metrics[$metric] = ['values' => [$value => 1]]; $this->metricTokens[$metric][$stackPtr] = true; } else if (isset($this->metricTokens[$metric][$stackPtr]) === false) { $this->metricTokens[$metric][$stackPtr] = true; if (isset($this->metrics[$metric]['values'][$value]) === false) { $this->metrics[$metric]['values'][$value] = 1; } else { $this->metrics[$metric]['values'][$value]++; } } return true; }//end recordMetric() /** * Returns the number of errors raised. * * @return int */ public function getErrorCount() { return $this->errorCount; }//end getErrorCount() /** * Returns the number of warnings raised. * * @return int */ public function getWarningCount() { return $this->warningCount; }//end getWarningCount() /** * Returns the number of fixable errors/warnings raised. * * @return int */ public function getFixableCount() { return $this->fixableCount; }//end getFixableCount() /** * Returns the number of fixed errors/warnings. * * @return int */ public function getFixedCount() { return $this->fixedCount; }//end getFixedCount() /** * Returns the list of ignored lines. * * @return array */ public function getIgnoredLines() { return $this->tokenizer->ignoredLines; }//end getIgnoredLines() /** * Returns the errors raised from processing this file. * * @return array */ public function getErrors() { return $this->errors; }//end getErrors() /** * Returns the warnings raised from processing this file. * * @return array */ public function getWarnings() { return $this->warnings; }//end getWarnings() /** * Returns the metrics found while processing this file. * * @return array */ public function getMetrics() { return $this->metrics; }//end getMetrics() /** * Returns the absolute filename of this file. * * @return string */ public function getFilename() { return $this->path; }//end getFilename() /** * Returns the declaration names for classes, interfaces, traits, and functions. * * @param int $stackPtr The position of the declaration token which * declared the class, interface, trait, or function. * * @return string|null The name of the class, interface, trait, or function; * or NULL if the function or class is anonymous. * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If the specified token is not of type * T_FUNCTION, T_CLASS, T_ANON_CLASS, * T_CLOSURE, T_TRAIT, or T_INTERFACE. */ public function getDeclarationName($stackPtr) { $tokenCode = $this->tokens[$stackPtr]['code']; if ($tokenCode === T_ANON_CLASS || $tokenCode === T_CLOSURE) { return null; } if ($tokenCode !== T_FUNCTION && $tokenCode !== T_CLASS && $tokenCode !== T_INTERFACE && $tokenCode !== T_TRAIT ) { throw new RuntimeException('Token type "'.$this->tokens[$stackPtr]['type'].'" is not T_FUNCTION, T_CLASS, T_INTERFACE or T_TRAIT'); } if ($tokenCode === T_FUNCTION && strtolower($this->tokens[$stackPtr]['content']) !== 'function' ) { // This is a function declared without the "function" keyword. // So this token is the function name. return $this->tokens[$stackPtr]['content']; } $content = null; for ($i = $stackPtr; $i < $this->numTokens; $i++) { if ($this->tokens[$i]['code'] === T_STRING || $this->tokens[$i]['code'] === T_FN ) { $content = $this->tokens[$i]['content']; break; } } return $content; }//end getDeclarationName() /** * Returns the method parameters for the specified function token. * * Also supports passing in a USE token for a closure use group. * * Each parameter is in the following format: * * * 0 => array( * 'name' => '$var', // The variable name. * 'token' => integer, // The stack pointer to the variable name. * 'content' => string, // The full content of the variable definition. * 'pass_by_reference' => boolean, // Is the variable passed by reference? * 'reference_token' => integer, // The stack pointer to the reference operator * // or FALSE if the param is not passed by reference. * 'variable_length' => boolean, // Is the param of variable length through use of `...` ? * 'variadic_token' => integer, // The stack pointer to the ... operator * // or FALSE if the param is not variable length. * 'type_hint' => string, // The type hint for the variable. * 'type_hint_token' => integer, // The stack pointer to the start of the type hint * // or FALSE if there is no type hint. * 'type_hint_end_token' => integer, // The stack pointer to the end of the type hint * // or FALSE if there is no type hint. * 'nullable_type' => boolean, // TRUE if the var type is nullable. * 'comma_token' => integer, // The stack pointer to the comma after the param * // or FALSE if this is the last param. * ) * * * Parameters with default values have an additional array indexes of: * 'default' => string, // The full content of the default value. * 'default_token' => integer, // The stack pointer to the start of the default value. * 'default_equal_token' => integer, // The stack pointer to the equals sign. * * @param int $stackPtr The position in the stack of the function token * to acquire the parameters for. * * @return array * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If the specified $stackPtr is not of * type T_FUNCTION, T_CLOSURE, T_USE, * or T_FN. */ public function getMethodParameters($stackPtr) { if ($this->tokens[$stackPtr]['code'] !== T_FUNCTION && $this->tokens[$stackPtr]['code'] !== T_CLOSURE && $this->tokens[$stackPtr]['code'] !== T_USE && $this->tokens[$stackPtr]['code'] !== T_FN ) { throw new RuntimeException('$stackPtr must be of type T_FUNCTION or T_CLOSURE or T_USE or T_FN'); } if ($this->tokens[$stackPtr]['code'] === T_USE) { $opener = $this->findNext(T_OPEN_PARENTHESIS, ($stackPtr + 1)); if ($opener === false || isset($this->tokens[$opener]['parenthesis_owner']) === true) { throw new RuntimeException('$stackPtr was not a valid T_USE'); } } else { if (isset($this->tokens[$stackPtr]['parenthesis_opener']) === false) { // Live coding or syntax error, so no params to find. return []; } $opener = $this->tokens[$stackPtr]['parenthesis_opener']; } if (isset($this->tokens[$opener]['parenthesis_closer']) === false) { // Live coding or syntax error, so no params to find. return []; } $closer = $this->tokens[$opener]['parenthesis_closer']; $vars = []; $currVar = null; $paramStart = ($opener + 1); $defaultStart = null; $equalToken = null; $paramCount = 0; $passByReference = false; $referenceToken = false; $variableLength = false; $variadicToken = false; $typeHint = ''; $typeHintToken = false; $typeHintEndToken = false; $nullableType = false; for ($i = $paramStart; $i <= $closer; $i++) { // Check to see if this token has a parenthesis or bracket opener. If it does // it's likely to be an array which might have arguments in it. This // could cause problems in our parsing below, so lets just skip to the // end of it. if (isset($this->tokens[$i]['parenthesis_opener']) === true) { // Don't do this if it's the close parenthesis for the method. if ($i !== $this->tokens[$i]['parenthesis_closer']) { $i = ($this->tokens[$i]['parenthesis_closer'] + 1); } } if (isset($this->tokens[$i]['bracket_opener']) === true) { // Don't do this if it's the close parenthesis for the method. if ($i !== $this->tokens[$i]['bracket_closer']) { $i = ($this->tokens[$i]['bracket_closer'] + 1); } } switch ($this->tokens[$i]['code']) { case T_BITWISE_AND: if ($defaultStart === null) { $passByReference = true; $referenceToken = $i; } break; case T_VARIABLE: $currVar = $i; break; case T_ELLIPSIS: $variableLength = true; $variadicToken = $i; break; case T_CALLABLE: if ($typeHintToken === false) { $typeHintToken = $i; } $typeHint .= $this->tokens[$i]['content']; $typeHintEndToken = $i; break; case T_SELF: case T_PARENT: case T_STATIC: // Self and parent are valid, static invalid, but was probably intended as type hint. if (isset($defaultStart) === false) { if ($typeHintToken === false) { $typeHintToken = $i; } $typeHint .= $this->tokens[$i]['content']; $typeHintEndToken = $i; } break; case T_STRING: // This is a string, so it may be a type hint, but it could // also be a constant used as a default value. $prevComma = false; for ($t = $i; $t >= $opener; $t--) { if ($this->tokens[$t]['code'] === T_COMMA) { $prevComma = $t; break; } } if ($prevComma !== false) { $nextEquals = false; for ($t = $prevComma; $t < $i; $t++) { if ($this->tokens[$t]['code'] === T_EQUAL) { $nextEquals = $t; break; } } if ($nextEquals !== false) { break; } } if ($defaultStart === null) { if ($typeHintToken === false) { $typeHintToken = $i; } $typeHint .= $this->tokens[$i]['content']; $typeHintEndToken = $i; } break; case T_NS_SEPARATOR: // Part of a type hint or default value. if ($defaultStart === null) { if ($typeHintToken === false) { $typeHintToken = $i; } $typeHint .= $this->tokens[$i]['content']; $typeHintEndToken = $i; } break; case T_NULLABLE: if ($defaultStart === null) { $nullableType = true; $typeHint .= $this->tokens[$i]['content']; $typeHintEndToken = $i; } break; case T_CLOSE_PARENTHESIS: case T_COMMA: // If it's null, then there must be no parameters for this // method. if ($currVar === null) { continue 2; } $vars[$paramCount] = []; $vars[$paramCount]['token'] = $currVar; $vars[$paramCount]['name'] = $this->tokens[$currVar]['content']; $vars[$paramCount]['content'] = trim($this->getTokensAsString($paramStart, ($i - $paramStart))); if ($defaultStart !== null) { $vars[$paramCount]['default'] = trim($this->getTokensAsString($defaultStart, ($i - $defaultStart))); $vars[$paramCount]['default_token'] = $defaultStart; $vars[$paramCount]['default_equal_token'] = $equalToken; } $vars[$paramCount]['pass_by_reference'] = $passByReference; $vars[$paramCount]['reference_token'] = $referenceToken; $vars[$paramCount]['variable_length'] = $variableLength; $vars[$paramCount]['variadic_token'] = $variadicToken; $vars[$paramCount]['type_hint'] = $typeHint; $vars[$paramCount]['type_hint_token'] = $typeHintToken; $vars[$paramCount]['type_hint_end_token'] = $typeHintEndToken; $vars[$paramCount]['nullable_type'] = $nullableType; if ($this->tokens[$i]['code'] === T_COMMA) { $vars[$paramCount]['comma_token'] = $i; } else { $vars[$paramCount]['comma_token'] = false; } // Reset the vars, as we are about to process the next parameter. $currVar = null; $paramStart = ($i + 1); $defaultStart = null; $equalToken = null; $passByReference = false; $referenceToken = false; $variableLength = false; $variadicToken = false; $typeHint = ''; $typeHintToken = false; $typeHintEndToken = false; $nullableType = false; $paramCount++; break; case T_EQUAL: $defaultStart = $this->findNext(Util\Tokens::$emptyTokens, ($i + 1), null, true); $equalToken = $i; break; }//end switch }//end for return $vars; }//end getMethodParameters() /** * Returns the visibility and implementation properties of a method. * * The format of the return value is: * * array( * 'scope' => 'public', // Public, private, or protected * 'scope_specified' => true, // TRUE if the scope keyword was found. * 'return_type' => '', // The return type of the method. * 'return_type_token' => integer, // The stack pointer to the start of the return type * // or FALSE if there is no return type. * 'nullable_return_type' => false, // TRUE if the return type is nullable. * 'is_abstract' => false, // TRUE if the abstract keyword was found. * 'is_final' => false, // TRUE if the final keyword was found. * 'is_static' => false, // TRUE if the static keyword was found. * 'has_body' => false, // TRUE if the method has a body * ); * * * @param int $stackPtr The position in the stack of the function token to * acquire the properties for. * * @return array * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If the specified position is not a * T_FUNCTION, T_CLOSURE, or T_FN token. */ public function getMethodProperties($stackPtr) { if ($this->tokens[$stackPtr]['code'] !== T_FUNCTION && $this->tokens[$stackPtr]['code'] !== T_CLOSURE && $this->tokens[$stackPtr]['code'] !== T_FN ) { throw new RuntimeException('$stackPtr must be of type T_FUNCTION or T_CLOSURE or T_FN'); } if ($this->tokens[$stackPtr]['code'] === T_FUNCTION) { $valid = [ T_PUBLIC => T_PUBLIC, T_PRIVATE => T_PRIVATE, T_PROTECTED => T_PROTECTED, T_STATIC => T_STATIC, T_FINAL => T_FINAL, T_ABSTRACT => T_ABSTRACT, T_WHITESPACE => T_WHITESPACE, T_COMMENT => T_COMMENT, T_DOC_COMMENT => T_DOC_COMMENT, ]; } else { $valid = [ T_STATIC => T_STATIC, T_WHITESPACE => T_WHITESPACE, T_COMMENT => T_COMMENT, T_DOC_COMMENT => T_DOC_COMMENT, ]; } $scope = 'public'; $scopeSpecified = false; $isAbstract = false; $isFinal = false; $isStatic = false; for ($i = ($stackPtr - 1); $i > 0; $i--) { if (isset($valid[$this->tokens[$i]['code']]) === false) { break; } switch ($this->tokens[$i]['code']) { case T_PUBLIC: $scope = 'public'; $scopeSpecified = true; break; case T_PRIVATE: $scope = 'private'; $scopeSpecified = true; break; case T_PROTECTED: $scope = 'protected'; $scopeSpecified = true; break; case T_ABSTRACT: $isAbstract = true; break; case T_FINAL: $isFinal = true; break; case T_STATIC: $isStatic = true; break; }//end switch }//end for $returnType = ''; $returnTypeToken = false; $nullableReturnType = false; $hasBody = true; if (isset($this->tokens[$stackPtr]['parenthesis_closer']) === true) { $scopeOpener = null; if (isset($this->tokens[$stackPtr]['scope_opener']) === true) { $scopeOpener = $this->tokens[$stackPtr]['scope_opener']; } $valid = [ T_STRING => T_STRING, T_CALLABLE => T_CALLABLE, T_SELF => T_SELF, T_PARENT => T_PARENT, T_NS_SEPARATOR => T_NS_SEPARATOR, ]; for ($i = $this->tokens[$stackPtr]['parenthesis_closer']; $i < $this->numTokens; $i++) { if (($scopeOpener === null && $this->tokens[$i]['code'] === T_SEMICOLON) || ($scopeOpener !== null && $i === $scopeOpener) ) { // End of function definition. break; } if ($this->tokens[$i]['code'] === T_NULLABLE) { $nullableReturnType = true; } if (isset($valid[$this->tokens[$i]['code']]) === true) { if ($returnTypeToken === false) { $returnTypeToken = $i; } $returnType .= $this->tokens[$i]['content']; } } if ($this->tokens[$stackPtr]['code'] === T_FN) { $bodyToken = T_FN_ARROW; } else { $bodyToken = T_OPEN_CURLY_BRACKET; } $end = $this->findNext([$bodyToken, T_SEMICOLON], $this->tokens[$stackPtr]['parenthesis_closer']); $hasBody = $this->tokens[$end]['code'] === $bodyToken; }//end if if ($returnType !== '' && $nullableReturnType === true) { $returnType = '?'.$returnType; } return [ 'scope' => $scope, 'scope_specified' => $scopeSpecified, 'return_type' => $returnType, 'return_type_token' => $returnTypeToken, 'nullable_return_type' => $nullableReturnType, 'is_abstract' => $isAbstract, 'is_final' => $isFinal, 'is_static' => $isStatic, 'has_body' => $hasBody, ]; }//end getMethodProperties() /** * Returns the visibility and implementation properties of a class member var. * * The format of the return value is: * * * array( * 'scope' => string, // Public, private, or protected. * 'scope_specified' => boolean, // TRUE if the scope was explicitly specified. * 'is_static' => boolean, // TRUE if the static keyword was found. * 'type' => string, // The type of the var (empty if no type specified). * 'type_token' => integer, // The stack pointer to the start of the type * // or FALSE if there is no type. * 'type_end_token' => integer, // The stack pointer to the end of the type * // or FALSE if there is no type. * 'nullable_type' => boolean, // TRUE if the type is nullable. * ); * * * @param int $stackPtr The position in the stack of the T_VARIABLE token to * acquire the properties for. * * @return array * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If the specified position is not a * T_VARIABLE token, or if the position is not * a class member variable. */ public function getMemberProperties($stackPtr) { if ($this->tokens[$stackPtr]['code'] !== T_VARIABLE) { throw new RuntimeException('$stackPtr must be of type T_VARIABLE'); } $conditions = array_keys($this->tokens[$stackPtr]['conditions']); $ptr = array_pop($conditions); if (isset($this->tokens[$ptr]) === false || ($this->tokens[$ptr]['code'] !== T_CLASS && $this->tokens[$ptr]['code'] !== T_ANON_CLASS && $this->tokens[$ptr]['code'] !== T_TRAIT) ) { if (isset($this->tokens[$ptr]) === true && $this->tokens[$ptr]['code'] === T_INTERFACE ) { // T_VARIABLEs in interfaces can actually be method arguments // but they wont be seen as being inside the method because there // are no scope openers and closers for abstract methods. If it is in // parentheses, we can be pretty sure it is a method argument. if (isset($this->tokens[$stackPtr]['nested_parenthesis']) === false || empty($this->tokens[$stackPtr]['nested_parenthesis']) === true ) { $error = 'Possible parse error: interfaces may not include member vars'; $this->addWarning($error, $stackPtr, 'Internal.ParseError.InterfaceHasMemberVar'); return []; } } else { throw new RuntimeException('$stackPtr is not a class member var'); } } // Make sure it's not a method parameter. if (empty($this->tokens[$stackPtr]['nested_parenthesis']) === false) { $parenthesis = array_keys($this->tokens[$stackPtr]['nested_parenthesis']); $deepestOpen = array_pop($parenthesis); if ($deepestOpen > $ptr && isset($this->tokens[$deepestOpen]['parenthesis_owner']) === true && $this->tokens[$this->tokens[$deepestOpen]['parenthesis_owner']]['code'] === T_FUNCTION ) { throw new RuntimeException('$stackPtr is not a class member var'); } } $valid = [ T_PUBLIC => T_PUBLIC, T_PRIVATE => T_PRIVATE, T_PROTECTED => T_PROTECTED, T_STATIC => T_STATIC, T_VAR => T_VAR, ]; $valid += Util\Tokens::$emptyTokens; $scope = 'public'; $scopeSpecified = false; $isStatic = false; $startOfStatement = $this->findPrevious( [ T_SEMICOLON, T_OPEN_CURLY_BRACKET, T_CLOSE_CURLY_BRACKET, ], ($stackPtr - 1) ); for ($i = ($startOfStatement + 1); $i < $stackPtr; $i++) { if (isset($valid[$this->tokens[$i]['code']]) === false) { break; } switch ($this->tokens[$i]['code']) { case T_PUBLIC: $scope = 'public'; $scopeSpecified = true; break; case T_PRIVATE: $scope = 'private'; $scopeSpecified = true; break; case T_PROTECTED: $scope = 'protected'; $scopeSpecified = true; break; case T_STATIC: $isStatic = true; break; } }//end for $type = ''; $typeToken = false; $typeEndToken = false; $nullableType = false; if ($i < $stackPtr) { // We've found a type. $valid = [ T_STRING => T_STRING, T_CALLABLE => T_CALLABLE, T_SELF => T_SELF, T_PARENT => T_PARENT, T_NS_SEPARATOR => T_NS_SEPARATOR, ]; for ($i; $i < $stackPtr; $i++) { if ($this->tokens[$i]['code'] === T_VARIABLE) { // Hit another variable in a group definition. break; } if ($this->tokens[$i]['code'] === T_NULLABLE) { $nullableType = true; } if (isset($valid[$this->tokens[$i]['code']]) === true) { $typeEndToken = $i; if ($typeToken === false) { $typeToken = $i; } $type .= $this->tokens[$i]['content']; } } if ($type !== '' && $nullableType === true) { $type = '?'.$type; } }//end if return [ 'scope' => $scope, 'scope_specified' => $scopeSpecified, 'is_static' => $isStatic, 'type' => $type, 'type_token' => $typeToken, 'type_end_token' => $typeEndToken, 'nullable_type' => $nullableType, ]; }//end getMemberProperties() /** * Returns the visibility and implementation properties of a class. * * The format of the return value is: * * array( * 'is_abstract' => false, // true if the abstract keyword was found. * 'is_final' => false, // true if the final keyword was found. * ); * * * @param int $stackPtr The position in the stack of the T_CLASS token to * acquire the properties for. * * @return array * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If the specified position is not a * T_CLASS token. */ public function getClassProperties($stackPtr) { if ($this->tokens[$stackPtr]['code'] !== T_CLASS) { throw new RuntimeException('$stackPtr must be of type T_CLASS'); } $valid = [ T_FINAL => T_FINAL, T_ABSTRACT => T_ABSTRACT, T_WHITESPACE => T_WHITESPACE, T_COMMENT => T_COMMENT, T_DOC_COMMENT => T_DOC_COMMENT, ]; $isAbstract = false; $isFinal = false; for ($i = ($stackPtr - 1); $i > 0; $i--) { if (isset($valid[$this->tokens[$i]['code']]) === false) { break; } switch ($this->tokens[$i]['code']) { case T_ABSTRACT: $isAbstract = true; break; case T_FINAL: $isFinal = true; break; } }//end for return [ 'is_abstract' => $isAbstract, 'is_final' => $isFinal, ]; }//end getClassProperties() /** * Determine if the passed token is a reference operator. * * Returns true if the specified token position represents a reference. * Returns false if the token represents a bitwise operator. * * @param int $stackPtr The position of the T_BITWISE_AND token. * * @return boolean */ public function isReference($stackPtr) { if ($this->tokens[$stackPtr]['code'] !== T_BITWISE_AND) { return false; } $tokenBefore = $this->findPrevious( Util\Tokens::$emptyTokens, ($stackPtr - 1), null, true ); if ($this->tokens[$tokenBefore]['code'] === T_FUNCTION || $this->tokens[$tokenBefore]['code'] === T_FN ) { // Function returns a reference. return true; } if ($this->tokens[$tokenBefore]['code'] === T_DOUBLE_ARROW) { // Inside a foreach loop or array assignment, this is a reference. return true; } if ($this->tokens[$tokenBefore]['code'] === T_AS) { // Inside a foreach loop, this is a reference. return true; } if (isset(Util\Tokens::$assignmentTokens[$this->tokens[$tokenBefore]['code']]) === true) { // This is directly after an assignment. It's a reference. Even if // it is part of an operation, the other tests will handle it. return true; } $tokenAfter = $this->findNext( Util\Tokens::$emptyTokens, ($stackPtr + 1), null, true ); if ($this->tokens[$tokenAfter]['code'] === T_NEW) { return true; } if (isset($this->tokens[$stackPtr]['nested_parenthesis']) === true) { $brackets = $this->tokens[$stackPtr]['nested_parenthesis']; $lastBracket = array_pop($brackets); if (isset($this->tokens[$lastBracket]['parenthesis_owner']) === true) { $owner = $this->tokens[$this->tokens[$lastBracket]['parenthesis_owner']]; if ($owner['code'] === T_FUNCTION || $owner['code'] === T_CLOSURE ) { $params = $this->getMethodParameters($this->tokens[$lastBracket]['parenthesis_owner']); foreach ($params as $param) { $varToken = $tokenAfter; if ($param['variable_length'] === true) { $varToken = $this->findNext( (Util\Tokens::$emptyTokens + [T_ELLIPSIS]), ($stackPtr + 1), null, true ); } if ($param['token'] === $varToken && $param['pass_by_reference'] === true ) { // Function parameter declared to be passed by reference. return true; } } }//end if } else { $prev = false; for ($t = ($this->tokens[$lastBracket]['parenthesis_opener'] - 1); $t >= 0; $t--) { if ($this->tokens[$t]['code'] !== T_WHITESPACE) { $prev = $t; break; } } if ($prev !== false && $this->tokens[$prev]['code'] === T_USE) { // Closure use by reference. return true; } }//end if }//end if // Pass by reference in function calls and assign by reference in arrays. if ($this->tokens[$tokenBefore]['code'] === T_OPEN_PARENTHESIS || $this->tokens[$tokenBefore]['code'] === T_COMMA || $this->tokens[$tokenBefore]['code'] === T_OPEN_SHORT_ARRAY ) { if ($this->tokens[$tokenAfter]['code'] === T_VARIABLE) { return true; } else { $skip = Util\Tokens::$emptyTokens; $skip[] = T_NS_SEPARATOR; $skip[] = T_SELF; $skip[] = T_PARENT; $skip[] = T_STATIC; $skip[] = T_STRING; $skip[] = T_NAMESPACE; $skip[] = T_DOUBLE_COLON; $nextSignificantAfter = $this->findNext( $skip, ($stackPtr + 1), null, true ); if ($this->tokens[$nextSignificantAfter]['code'] === T_VARIABLE) { return true; } }//end if }//end if return false; }//end isReference() /** * Returns the content of the tokens from the specified start position in * the token stack for the specified length. * * @param int $start The position to start from in the token stack. * @param int $length The length of tokens to traverse from the start pos. * @param bool $origContent Whether the original content or the tab replaced * content should be used. * * @return string The token contents. * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If the specified position does not exist. */ public function getTokensAsString($start, $length, $origContent=false) { if (is_int($start) === false || isset($this->tokens[$start]) === false) { throw new RuntimeException('The $start position for getTokensAsString() must exist in the token stack'); } if (is_int($length) === false || $length <= 0) { return ''; } $str = ''; $end = ($start + $length); if ($end > $this->numTokens) { $end = $this->numTokens; } for ($i = $start; $i < $end; $i++) { // If tabs are being converted to spaces by the tokeniser, the // original content should be used instead of the converted content. if ($origContent === true && isset($this->tokens[$i]['orig_content']) === true) { $str .= $this->tokens[$i]['orig_content']; } else { $str .= $this->tokens[$i]['content']; } } return $str; }//end getTokensAsString() /** * Returns the position of the previous specified token(s). * * If a value is specified, the previous token of the specified type(s) * containing the specified value will be returned. * * Returns false if no token can be found. * * @param int|string|array $types The type(s) of tokens to search for. * @param int $start The position to start searching from in the * token stack. * @param int $end The end position to fail if no token is found. * if not specified or null, end will default to * the start of the token stack. * @param bool $exclude If true, find the previous token that is NOT of * the types specified in $types. * @param string $value The value that the token(s) must be equal to. * If value is omitted, tokens with any value will * be returned. * @param bool $local If true, tokens outside the current statement * will not be checked. IE. checking will stop * at the previous semi-colon found. * * @return int|false * @see findNext() */ public function findPrevious( $types, $start, $end=null, $exclude=false, $value=null, $local=false ) { $types = (array) $types; if ($end === null) { $end = 0; } for ($i = $start; $i >= $end; $i--) { $found = (bool) $exclude; foreach ($types as $type) { if ($this->tokens[$i]['code'] === $type) { $found = !$exclude; break; } } if ($found === true) { if ($value === null) { return $i; } else if ($this->tokens[$i]['content'] === $value) { return $i; } } if ($local === true) { if (isset($this->tokens[$i]['scope_opener']) === true && $i === $this->tokens[$i]['scope_closer'] ) { $i = $this->tokens[$i]['scope_opener']; } else if (isset($this->tokens[$i]['bracket_opener']) === true && $i === $this->tokens[$i]['bracket_closer'] ) { $i = $this->tokens[$i]['bracket_opener']; } else if (isset($this->tokens[$i]['parenthesis_opener']) === true && $i === $this->tokens[$i]['parenthesis_closer'] ) { $i = $this->tokens[$i]['parenthesis_opener']; } else if ($this->tokens[$i]['code'] === T_SEMICOLON) { break; } } }//end for return false; }//end findPrevious() /** * Returns the position of the next specified token(s). * * If a value is specified, the next token of the specified type(s) * containing the specified value will be returned. * * Returns false if no token can be found. * * @param int|string|array $types The type(s) of tokens to search for. * @param int $start The position to start searching from in the * token stack. * @param int $end The end position to fail if no token is found. * if not specified or null, end will default to * the end of the token stack. * @param bool $exclude If true, find the next token that is NOT of * a type specified in $types. * @param string $value The value that the token(s) must be equal to. * If value is omitted, tokens with any value will * be returned. * @param bool $local If true, tokens outside the current statement * will not be checked. i.e., checking will stop * at the next semi-colon found. * * @return int|false * @see findPrevious() */ public function findNext( $types, $start, $end=null, $exclude=false, $value=null, $local=false ) { $types = (array) $types; if ($end === null || $end > $this->numTokens) { $end = $this->numTokens; } for ($i = $start; $i < $end; $i++) { $found = (bool) $exclude; foreach ($types as $type) { if ($this->tokens[$i]['code'] === $type) { $found = !$exclude; break; } } if ($found === true) { if ($value === null) { return $i; } else if ($this->tokens[$i]['content'] === $value) { return $i; } } if ($local === true && $this->tokens[$i]['code'] === T_SEMICOLON) { break; } }//end for return false; }//end findNext() /** * Returns the position of the first non-whitespace token in a statement. * * @param int $start The position to start searching from in the token stack. * @param int|string|array $ignore Token types that should not be considered stop points. * * @return int */ public function findStartOfStatement($start, $ignore=null) { $endTokens = Util\Tokens::$blockOpeners; $endTokens[T_COLON] = true; $endTokens[T_COMMA] = true; $endTokens[T_DOUBLE_ARROW] = true; $endTokens[T_SEMICOLON] = true; $endTokens[T_OPEN_TAG] = true; $endTokens[T_CLOSE_TAG] = true; $endTokens[T_OPEN_SHORT_ARRAY] = true; if ($ignore !== null) { $ignore = (array) $ignore; foreach ($ignore as $code) { unset($endTokens[$code]); } } $lastNotEmpty = $start; for ($i = $start; $i >= 0; $i--) { if (isset($endTokens[$this->tokens[$i]['code']]) === true) { // Found the end of the previous statement. return $lastNotEmpty; } if (isset($this->tokens[$i]['scope_opener']) === true && $i === $this->tokens[$i]['scope_closer'] ) { // Found the end of the previous scope block. return $lastNotEmpty; } // Skip nested statements. if (isset($this->tokens[$i]['bracket_opener']) === true && $i === $this->tokens[$i]['bracket_closer'] ) { $i = $this->tokens[$i]['bracket_opener']; } else if (isset($this->tokens[$i]['parenthesis_opener']) === true && $i === $this->tokens[$i]['parenthesis_closer'] ) { $i = $this->tokens[$i]['parenthesis_opener']; } if (isset(Util\Tokens::$emptyTokens[$this->tokens[$i]['code']]) === false) { $lastNotEmpty = $i; } }//end for return 0; }//end findStartOfStatement() /** * Returns the position of the last non-whitespace token in a statement. * * @param int $start The position to start searching from in the token stack. * @param int|string|array $ignore Token types that should not be considered stop points. * * @return int */ public function findEndOfStatement($start, $ignore=null) { $endTokens = [ T_COLON => true, T_COMMA => true, T_DOUBLE_ARROW => true, T_SEMICOLON => true, T_CLOSE_PARENTHESIS => true, T_CLOSE_SQUARE_BRACKET => true, T_CLOSE_CURLY_BRACKET => true, T_CLOSE_SHORT_ARRAY => true, T_OPEN_TAG => true, T_CLOSE_TAG => true, ]; if ($ignore !== null) { $ignore = (array) $ignore; foreach ($ignore as $code) { unset($endTokens[$code]); } } $lastNotEmpty = $start; for ($i = $start; $i < $this->numTokens; $i++) { if ($i !== $start && isset($endTokens[$this->tokens[$i]['code']]) === true) { // Found the end of the statement. if ($this->tokens[$i]['code'] === T_CLOSE_PARENTHESIS || $this->tokens[$i]['code'] === T_CLOSE_SQUARE_BRACKET || $this->tokens[$i]['code'] === T_CLOSE_CURLY_BRACKET || $this->tokens[$i]['code'] === T_CLOSE_SHORT_ARRAY || $this->tokens[$i]['code'] === T_OPEN_TAG || $this->tokens[$i]['code'] === T_CLOSE_TAG ) { return $lastNotEmpty; } return $i; } // Skip nested statements. if (isset($this->tokens[$i]['scope_closer']) === true && ($i === $this->tokens[$i]['scope_opener'] || $i === $this->tokens[$i]['scope_condition']) ) { if ($this->tokens[$i]['code'] === T_FN) { $i = ($this->tokens[$i]['scope_closer'] - 1); continue; } if ($i === $start && isset(Util\Tokens::$scopeOpeners[$this->tokens[$i]['code']]) === true) { return $this->tokens[$i]['scope_closer']; } $i = $this->tokens[$i]['scope_closer']; } else if (isset($this->tokens[$i]['bracket_closer']) === true && $i === $this->tokens[$i]['bracket_opener'] ) { $i = $this->tokens[$i]['bracket_closer']; } else if (isset($this->tokens[$i]['parenthesis_closer']) === true && $i === $this->tokens[$i]['parenthesis_opener'] ) { $i = $this->tokens[$i]['parenthesis_closer']; } else if ($this->tokens[$i]['code'] === T_OPEN_USE_GROUP) { $end = $this->findNext(T_CLOSE_USE_GROUP, ($i + 1)); if ($end !== false) { $i = $end; } }//end if if (isset(Util\Tokens::$emptyTokens[$this->tokens[$i]['code']]) === false) { $lastNotEmpty = $i; } }//end for return ($this->numTokens - 1); }//end findEndOfStatement() /** * Returns the position of the first token on a line, matching given type. * * Returns false if no token can be found. * * @param int|string|array $types The type(s) of tokens to search for. * @param int $start The position to start searching from in the * token stack. The first token matching on * this line before this token will be returned. * @param bool $exclude If true, find the token that is NOT of * the types specified in $types. * @param string $value The value that the token must be equal to. * If value is omitted, tokens with any value will * be returned. * * @return int|false */ public function findFirstOnLine($types, $start, $exclude=false, $value=null) { if (is_array($types) === false) { $types = [$types]; } $foundToken = false; for ($i = $start; $i >= 0; $i--) { if ($this->tokens[$i]['line'] < $this->tokens[$start]['line']) { break; } $found = $exclude; foreach ($types as $type) { if ($exclude === false) { if ($this->tokens[$i]['code'] === $type) { $found = true; break; } } else { if ($this->tokens[$i]['code'] === $type) { $found = false; break; } } } if ($found === true) { if ($value === null) { $foundToken = $i; } else if ($this->tokens[$i]['content'] === $value) { $foundToken = $i; } } }//end for return $foundToken; }//end findFirstOnLine() /** * Determine if the passed token has a condition of one of the passed types. * * @param int $stackPtr The position of the token we are checking. * @param int|string|array $types The type(s) of tokens to search for. * * @return boolean */ public function hasCondition($stackPtr, $types) { // Check for the existence of the token. if (isset($this->tokens[$stackPtr]) === false) { return false; } // Make sure the token has conditions. if (isset($this->tokens[$stackPtr]['conditions']) === false) { return false; } $types = (array) $types; $conditions = $this->tokens[$stackPtr]['conditions']; foreach ($types as $type) { if (in_array($type, $conditions, true) === true) { // We found a token with the required type. return true; } } return false; }//end hasCondition() /** * Return the position of the condition for the passed token. * * Returns FALSE if the token does not have the condition. * * @param int $stackPtr The position of the token we are checking. * @param int|string $type The type of token to search for. * @param bool $first If TRUE, will return the matched condition * furtherest away from the passed token. * If FALSE, will return the matched condition * closest to the passed token. * * @return int|false */ public function getCondition($stackPtr, $type, $first=true) { // Check for the existence of the token. if (isset($this->tokens[$stackPtr]) === false) { return false; } // Make sure the token has conditions. if (isset($this->tokens[$stackPtr]['conditions']) === false) { return false; } $conditions = $this->tokens[$stackPtr]['conditions']; if ($first === false) { $conditions = array_reverse($conditions, true); } foreach ($conditions as $token => $condition) { if ($condition === $type) { return $token; } } return false; }//end getCondition() /** * Returns the name of the class that the specified class extends. * (works for classes, anonymous classes and interfaces) * * Returns FALSE on error or if there is no extended class name. * * @param int $stackPtr The stack position of the class. * * @return string|false */ public function findExtendedClassName($stackPtr) { // Check for the existence of the token. if (isset($this->tokens[$stackPtr]) === false) { return false; } if ($this->tokens[$stackPtr]['code'] !== T_CLASS && $this->tokens[$stackPtr]['code'] !== T_ANON_CLASS && $this->tokens[$stackPtr]['code'] !== T_INTERFACE ) { return false; } if (isset($this->tokens[$stackPtr]['scope_opener']) === false) { return false; } $classOpenerIndex = $this->tokens[$stackPtr]['scope_opener']; $extendsIndex = $this->findNext(T_EXTENDS, $stackPtr, $classOpenerIndex); if ($extendsIndex === false) { return false; } $find = [ T_NS_SEPARATOR, T_STRING, T_WHITESPACE, ]; $end = $this->findNext($find, ($extendsIndex + 1), ($classOpenerIndex + 1), true); $name = $this->getTokensAsString(($extendsIndex + 1), ($end - $extendsIndex - 1)); $name = trim($name); if ($name === '') { return false; } return $name; }//end findExtendedClassName() /** * Returns the names of the interfaces that the specified class implements. * * Returns FALSE on error or if there are no implemented interface names. * * @param int $stackPtr The stack position of the class. * * @return array|false */ public function findImplementedInterfaceNames($stackPtr) { // Check for the existence of the token. if (isset($this->tokens[$stackPtr]) === false) { return false; } if ($this->tokens[$stackPtr]['code'] !== T_CLASS && $this->tokens[$stackPtr]['code'] !== T_ANON_CLASS ) { return false; } if (isset($this->tokens[$stackPtr]['scope_closer']) === false) { return false; } $classOpenerIndex = $this->tokens[$stackPtr]['scope_opener']; $implementsIndex = $this->findNext(T_IMPLEMENTS, $stackPtr, $classOpenerIndex); if ($implementsIndex === false) { return false; } $find = [ T_NS_SEPARATOR, T_STRING, T_WHITESPACE, T_COMMA, ]; $end = $this->findNext($find, ($implementsIndex + 1), ($classOpenerIndex + 1), true); $name = $this->getTokensAsString(($implementsIndex + 1), ($end - $implementsIndex - 1)); $name = trim($name); if ($name === '') { return false; } else { $names = explode(',', $name); $names = array_map('trim', $names); return $names; } }//end findImplementedInterfaceNames() }//end class PHP_CodeSniffer-3.5.4/src/Files/FileList.php0000644000076500000240000001374113614652361020377 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Files; use PHP_CodeSniffer\Autoload; use PHP_CodeSniffer\Util; use PHP_CodeSniffer\Ruleset; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Exceptions\DeepExitException; class FileList implements \Iterator, \Countable { /** * A list of file paths that are included in the list. * * @var array */ private $files = []; /** * The number of files in the list. * * @var integer */ private $numFiles = 0; /** * The config data for the run. * * @var \PHP_CodeSniffer\Config */ public $config = null; /** * The ruleset used for the run. * * @var \PHP_CodeSniffer\Ruleset */ public $ruleset = null; /** * An array of patterns to use for skipping files. * * @var array */ protected $ignorePatterns = []; /** * Constructs a file list and loads in an array of file paths to process. * * @param \PHP_CodeSniffer\Config $config The config data for the run. * @param \PHP_CodeSniffer\Ruleset $ruleset The ruleset used for the run. * * @return void */ public function __construct(Config $config, Ruleset $ruleset) { $this->ruleset = $ruleset; $this->config = $config; $paths = $config->files; foreach ($paths as $path) { $isPharFile = Util\Common::isPharFile($path); if (is_dir($path) === true || $isPharFile === true) { if ($isPharFile === true) { $path = 'phar://'.$path; } $filterClass = $this->getFilterClass(); $di = new \RecursiveDirectoryIterator($path, (\RecursiveDirectoryIterator::SKIP_DOTS | \FilesystemIterator::FOLLOW_SYMLINKS)); $filter = new $filterClass($di, $path, $config, $ruleset); $iterator = new \RecursiveIteratorIterator($filter); foreach ($iterator as $file) { $this->files[$file->getPathname()] = null; $this->numFiles++; } } else { $this->addFile($path); }//end if }//end foreach reset($this->files); }//end __construct() /** * Add a file to the list. * * If a file object has already been created, it can be passed here. * If it is left NULL, it will be created when accessed. * * @param string $path The path to the file being added. * @param \PHP_CodeSniffer\Files\File $file The file being added. * * @return void */ public function addFile($path, $file=null) { // No filtering is done for STDIN when the filename // has not been specified. if ($path === 'STDIN') { $this->files[$path] = $file; $this->numFiles++; return; } $filterClass = $this->getFilterClass(); $di = new \RecursiveArrayIterator([$path]); $filter = new $filterClass($di, $path, $this->config, $this->ruleset); $iterator = new \RecursiveIteratorIterator($filter); foreach ($iterator as $path) { $this->files[$path] = $file; $this->numFiles++; } }//end addFile() /** * Get the class name of the filter being used for the run. * * @return string * @throws \PHP_CodeSniffer\Exceptions\DeepExitException If the specified filter could not be found. */ private function getFilterClass() { $filterType = $this->config->filter; if ($filterType === null) { $filterClass = '\PHP_CodeSniffer\Filters\Filter'; } else { if (strpos($filterType, '.') !== false) { // This is a path to a custom filter class. $filename = realpath($filterType); if ($filename === false) { $error = "ERROR: Custom filter \"$filterType\" not found".PHP_EOL; throw new DeepExitException($error, 3); } $filterClass = Autoload::loadFile($filename); } else { $filterClass = '\PHP_CodeSniffer\Filters\\'.$filterType; } } return $filterClass; }//end getFilterClass() /** * Rewind the iterator to the first file. * * @return void */ public function rewind() { reset($this->files); }//end rewind() /** * Get the file that is currently being processed. * * @return \PHP_CodeSniffer\Files\File */ public function current() { $path = key($this->files); if ($this->files[$path] === null) { $this->files[$path] = new LocalFile($path, $this->ruleset, $this->config); } return $this->files[$path]; }//end current() /** * Return the file path of the current file being processed. * * @return void */ public function key() { return key($this->files); }//end key() /** * Move forward to the next file. * * @return void */ public function next() { next($this->files); }//end next() /** * Checks if current position is valid. * * @return boolean */ public function valid() { if (current($this->files) === false) { return false; } return true; }//end valid() /** * Return the number of files in the list. * * @return integer */ public function count() { return $this->numFiles; }//end count() }//end class PHP_CodeSniffer-3.5.4/src/Files/LocalFile.php0000644000076500000240000001552213614652361020515 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Files; use PHP_CodeSniffer\Ruleset; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Util\Cache; class LocalFile extends File { /** * Creates a LocalFile object and sets the content. * * @param string $path The absolute path to the file. * @param \PHP_CodeSniffer\Ruleset $ruleset The ruleset used for the run. * @param \PHP_CodeSniffer\Config $config The config data for the run. * * @return void */ public function __construct($path, Ruleset $ruleset, Config $config) { $this->path = trim($path); if (is_readable($this->path) === false) { parent::__construct($this->path, $ruleset, $config); $error = 'Error opening file; file no longer exists or you do not have access to read the file'; $this->addMessage(true, $error, 1, 1, 'Internal.LocalFile', [], 5, false); $this->ignored = true; return; } // Before we go and spend time tokenizing this file, just check // to see if there is a tag up top to indicate that the whole // file should be ignored. It must be on one of the first two lines. if ($config->annotations === true) { $handle = fopen($this->path, 'r'); if ($handle !== false) { $firstContent = fgets($handle); $firstContent .= fgets($handle); fclose($handle); if (strpos($firstContent, '@codingStandardsIgnoreFile') !== false || stripos($firstContent, 'phpcs:ignorefile') !== false ) { // We are ignoring the whole file. $this->ignored = true; return; } } } $this->reloadContent(); parent::__construct($this->path, $ruleset, $config); }//end __construct() /** * Loads the latest version of the file's content from the file system. * * @return void */ public function reloadContent() { $this->setContent(file_get_contents($this->path)); }//end reloadContent() /** * Processes the file. * * @return void */ public function process() { if ($this->ignored === true) { return; } if ($this->configCache['cache'] === false) { parent::process(); return; } $hash = md5_file($this->path); $hash .= fileperms($this->path); $cache = Cache::get($this->path); if ($cache !== false && $cache['hash'] === $hash) { // We can't filter metrics, so just load all of them. $this->metrics = $cache['metrics']; if ($this->configCache['recordErrors'] === true) { // Replay the cached errors and warnings to filter out the ones // we don't need for this specific run. $this->configCache['cache'] = false; $this->replayErrors($cache['errors'], $cache['warnings']); $this->configCache['cache'] = true; } else { $this->errorCount = $cache['errorCount']; $this->warningCount = $cache['warningCount']; $this->fixableCount = $cache['fixableCount']; } if (PHP_CODESNIFFER_VERBOSITY > 0 || (PHP_CODESNIFFER_CBF === true && empty($this->config->files) === false) ) { echo "[loaded from cache]... "; } $this->numTokens = $cache['numTokens']; $this->fromCache = true; return; }//end if if (PHP_CODESNIFFER_VERBOSITY > 1) { echo PHP_EOL; } parent::process(); $cache = [ 'hash' => $hash, 'errors' => $this->errors, 'warnings' => $this->warnings, 'metrics' => $this->metrics, 'errorCount' => $this->errorCount, 'warningCount' => $this->warningCount, 'fixableCount' => $this->fixableCount, 'numTokens' => $this->numTokens, ]; Cache::set($this->path, $cache); // During caching, we don't filter out errors in any way, so // we need to do that manually now by replaying them. if ($this->configCache['recordErrors'] === true) { $this->configCache['cache'] = false; $this->replayErrors($this->errors, $this->warnings); $this->configCache['cache'] = true; } }//end process() /** * Clears and replays error and warnings for the file. * * Replaying errors and warnings allows for filtering rules to be changed * and then errors and warnings to be reapplied with the new rules. This is * particularly useful while caching. * * @param array $errors The list of errors to replay. * @param array $warnings The list of warnings to replay. * * @return void */ private function replayErrors($errors, $warnings) { $this->errors = []; $this->warnings = []; $this->errorCount = 0; $this->warningCount = 0; $this->fixableCount = 0; $this->replayingErrors = true; foreach ($errors as $line => $lineErrors) { foreach ($lineErrors as $column => $colErrors) { foreach ($colErrors as $error) { $this->activeListener = $error['listener']; $this->addMessage( true, $error['message'], $line, $column, $error['source'], [], $error['severity'], $error['fixable'] ); } } } foreach ($warnings as $line => $lineErrors) { foreach ($lineErrors as $column => $colErrors) { foreach ($colErrors as $error) { $this->activeListener = $error['listener']; $this->addMessage( false, $error['message'], $line, $column, $error['source'], [], $error['severity'], $error['fixable'] ); } } } $this->replayingErrors = false; }//end replayErrors() }//end class PHP_CodeSniffer-3.5.4/src/Filters/ExactMatch.php0000644000076500000240000000504213614652361021246 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Filters; use PHP_CodeSniffer\Util; abstract class ExactMatch extends Filter { /** * A list of files to exclude. * * @var array */ private $blacklist = null; /** * A list of files to include. * * If the whitelist is empty, only files in the blacklist will be excluded. * * @var array */ private $whitelist = null; /** * Check whether the current element of the iterator is acceptable. * * If a file is both blacklisted and whitelisted, it will be deemed unacceptable. * * @return bool */ public function accept() { if (parent::accept() === false) { return false; } if ($this->blacklist === null) { $this->blacklist = $this->getblacklist(); } if ($this->whitelist === null) { $this->whitelist = $this->getwhitelist(); } $filePath = Util\Common::realpath($this->current()); // If file is both blacklisted and whitelisted, the blacklist takes precedence. if (isset($this->blacklist[$filePath]) === true) { return false; } if (empty($this->whitelist) === true && empty($this->blacklist) === false) { // We are only checking a blacklist, so everything else should be whitelisted. return true; } return isset($this->whitelist[$filePath]); }//end accept() /** * Returns an iterator for the current entry. * * Ensures that the blacklist and whitelist are preserved so they don't have * to be generated each time. * * @return \RecursiveIterator */ public function getChildren() { $children = parent::getChildren(); $children->blacklist = $this->blacklist; $children->whitelist = $this->whitelist; return $children; }//end getChildren() /** * Get a list of blacklisted file paths. * * @return array */ abstract protected function getBlacklist(); /** * Get a list of whitelisted file paths. * * @return array */ abstract protected function getWhitelist(); }//end class PHP_CodeSniffer-3.5.4/src/Filters/Filter.php0000644000076500000240000002041613614652361020454 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Filters; use PHP_CodeSniffer\Util; use PHP_CodeSniffer\Ruleset; use PHP_CodeSniffer\Config; class Filter extends \RecursiveFilterIterator { /** * The top-level path we are filtering. * * @var string */ protected $basedir = null; /** * The config data for the run. * * @var \PHP_CodeSniffer\Config */ protected $config = null; /** * The ruleset used for the run. * * @var \PHP_CodeSniffer\Ruleset */ protected $ruleset = null; /** * A list of ignore patterns that apply to directories only. * * @var array */ protected $ignoreDirPatterns = null; /** * A list of ignore patterns that apply to files only. * * @var array */ protected $ignoreFilePatterns = null; /** * A list of file paths we've already accepted. * * Used to ensure we aren't following circular symlinks. * * @var array */ protected $acceptedPaths = []; /** * Constructs a filter. * * @param \RecursiveIterator $iterator The iterator we are using to get file paths. * @param string $basedir The top-level path we are filtering. * @param \PHP_CodeSniffer\Config $config The config data for the run. * @param \PHP_CodeSniffer\Ruleset $ruleset The ruleset used for the run. * * @return void */ public function __construct($iterator, $basedir, Config $config, Ruleset $ruleset) { parent::__construct($iterator); $this->basedir = $basedir; $this->config = $config; $this->ruleset = $ruleset; }//end __construct() /** * Check whether the current element of the iterator is acceptable. * * Files are checked for allowed extensions and ignore patterns. * Directories are checked for ignore patterns only. * * @return bool */ public function accept() { $filePath = $this->current(); $realPath = Util\Common::realpath($filePath); if ($realPath !== false) { // It's a real path somewhere, so record it // to check for circular symlinks. if (isset($this->acceptedPaths[$realPath]) === true) { // We've been here before. return false; } } $filePath = $this->current(); if (is_dir($filePath) === true) { if ($this->config->local === true) { return false; } } else if ($this->shouldProcessFile($filePath) === false) { return false; } if ($this->shouldIgnorePath($filePath) === true) { return false; } $this->acceptedPaths[$realPath] = true; return true; }//end accept() /** * Returns an iterator for the current entry. * * Ensures that the ignore patterns are preserved so they don't have * to be generated each time. * * @return \RecursiveIterator */ public function getChildren() { $filterClass = get_called_class(); $children = new $filterClass( new \RecursiveDirectoryIterator($this->current(), (\RecursiveDirectoryIterator::SKIP_DOTS | \FilesystemIterator::FOLLOW_SYMLINKS)), $this->basedir, $this->config, $this->ruleset ); // Set the ignore patterns so we don't have to generate them again. $children->ignoreDirPatterns = $this->ignoreDirPatterns; $children->ignoreFilePatterns = $this->ignoreFilePatterns; $children->acceptedPaths = $this->acceptedPaths; return $children; }//end getChildren() /** * Checks filtering rules to see if a file should be checked. * * Checks both file extension filters and path ignore filters. * * @param string $path The path to the file being checked. * * @return bool */ protected function shouldProcessFile($path) { // Check that the file's extension is one we are checking. // We are strict about checking the extension and we don't // let files through with no extension or that start with a dot. $fileName = basename($path); $fileParts = explode('.', $fileName); if ($fileParts[0] === $fileName || $fileParts[0] === '') { return false; } // Checking multi-part file extensions, so need to create a // complete extension list and make sure one is allowed. $extensions = []; array_shift($fileParts); foreach ($fileParts as $part) { $extensions[implode('.', $fileParts)] = 1; array_shift($fileParts); } $matches = array_intersect_key($extensions, $this->config->extensions); if (empty($matches) === true) { return false; } return true; }//end shouldProcessFile() /** * Checks filtering rules to see if a path should be ignored. * * @param string $path The path to the file or directory being checked. * * @return bool */ protected function shouldIgnorePath($path) { if ($this->ignoreFilePatterns === null) { $this->ignoreDirPatterns = []; $this->ignoreFilePatterns = []; $ignorePatterns = $this->config->ignored; $rulesetIgnorePatterns = $this->ruleset->getIgnorePatterns(); foreach ($rulesetIgnorePatterns as $pattern => $type) { // Ignore standard/sniff specific exclude rules. if (is_array($type) === true) { continue; } $ignorePatterns[$pattern] = $type; } foreach ($ignorePatterns as $pattern => $type) { // If the ignore pattern ends with /* then it is ignoring an entire directory. if (substr($pattern, -2) === '/*') { // Need to check this pattern for dirs as well as individual file paths. $this->ignoreFilePatterns[$pattern] = $type; $pattern = substr($pattern, 0, -2); $this->ignoreDirPatterns[$pattern] = $type; } else { // This is a file-specific pattern, so only need to check this // for individual file paths. $this->ignoreFilePatterns[$pattern] = $type; } } }//end if $relativePath = $path; if (strpos($path, $this->basedir) === 0) { // The +1 cuts off the directory separator as well. $relativePath = substr($path, (strlen($this->basedir) + 1)); } if (is_dir($path) === true) { $ignorePatterns = $this->ignoreDirPatterns; } else { $ignorePatterns = $this->ignoreFilePatterns; } foreach ($ignorePatterns as $pattern => $type) { // Maintains backwards compatibility in case the ignore pattern does // not have a relative/absolute value. if (is_int($pattern) === true) { $pattern = $type; $type = 'absolute'; } $replacements = [ '\\,' => ',', '*' => '.*', ]; // We assume a / directory separator, as do the exclude rules // most developers write, so we need a special case for any system // that is different. if (DIRECTORY_SEPARATOR === '\\') { $replacements['/'] = '\\\\'; } $pattern = strtr($pattern, $replacements); if ($type === 'relative') { $testPath = $relativePath; } else { $testPath = $path; } $pattern = '`'.$pattern.'`i'; if (preg_match($pattern, $testPath) === 1) { return true; } }//end foreach return false; }//end shouldIgnorePath() }//end class PHP_CodeSniffer-3.5.4/src/Filters/GitModified.php0000644000076500000240000000261713614652361021416 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Filters; use PHP_CodeSniffer\Util; class GitModified extends ExactMatch { /** * Get a list of blacklisted file paths. * * @return array */ protected function getBlacklist() { return []; }//end getBlacklist() /** * Get a list of whitelisted file paths. * * @return array */ protected function getWhitelist() { $modified = []; $cmd = 'git ls-files -o -m --exclude-standard -- '.escapeshellarg($this->basedir); $output = []; exec($cmd, $output); $basedir = $this->basedir; if (is_dir($basedir) === false) { $basedir = dirname($basedir); } foreach ($output as $path) { $path = Util\Common::realpath($path); if ($path === false) { continue; } do { $modified[$path] = true; $path = dirname($path); } while ($path !== $basedir); } return $modified; }//end getWhitelist() }//end class PHP_CodeSniffer-3.5.4/src/Filters/GitStaged.php0000644000076500000240000000301313614652361021074 0ustar gsherwoodstaff * @copyright 2018 Juliette Reinders Folmer. All rights reserved. * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Filters; use PHP_CodeSniffer\Util; class GitStaged extends ExactMatch { /** * Get a list of blacklisted file paths. * * @return array */ protected function getBlacklist() { return []; }//end getBlacklist() /** * Get a list of whitelisted file paths. * * @return array */ protected function getWhitelist() { $modified = []; $cmd = 'git diff --cached --name-only -- '.escapeshellarg($this->basedir); $output = []; exec($cmd, $output); $basedir = $this->basedir; if (is_dir($basedir) === false) { $basedir = dirname($basedir); } foreach ($output as $path) { $path = Util\Common::realpath($path); if ($path === false) { // Skip deleted files. continue; } do { $modified[$path] = true; $path = dirname($path); } while ($path !== $basedir); } return $modified; }//end getWhitelist() }//end class PHP_CodeSniffer-3.5.4/src/Generators/Generator.php0000644000076500000240000000612213614652361021654 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Generators; use PHP_CodeSniffer\Ruleset; use PHP_CodeSniffer\Autoload; abstract class Generator { /** * The ruleset used for the run. * * @var \PHP_CodeSniffer\Ruleset */ public $ruleset = null; /** * XML documentation files used to produce the final output. * * @var string[] */ public $docFiles = []; /** * Constructs a doc generator. * * @param \PHP_CodeSniffer\Ruleset $ruleset The ruleset used for the run. * * @see generate() */ public function __construct(Ruleset $ruleset) { $this->ruleset = $ruleset; foreach ($ruleset->sniffs as $className => $sniffClass) { $file = Autoload::getLoadedFileName($className); $docFile = str_replace( DIRECTORY_SEPARATOR.'Sniffs'.DIRECTORY_SEPARATOR, DIRECTORY_SEPARATOR.'Docs'.DIRECTORY_SEPARATOR, $file ); $docFile = str_replace('Sniff.php', 'Standard.xml', $docFile); if (is_file($docFile) === true) { $this->docFiles[] = $docFile; } } }//end __construct() /** * Retrieves the title of the sniff from the DOMNode supplied. * * @param \DOMNode $doc The DOMNode object for the sniff. * It represents the "documentation" tag in the XML * standard file. * * @return string */ protected function getTitle(\DOMNode $doc) { return $doc->getAttribute('title'); }//end getTitle() /** * Generates the documentation for a standard. * * It's probably wise for doc generators to override this method so they * have control over how the docs are produced. Otherwise, the processSniff * method should be overridden to output content for each sniff. * * @return void * @see processSniff() */ public function generate() { foreach ($this->docFiles as $file) { $doc = new \DOMDocument(); $doc->load($file); $documentation = $doc->getElementsByTagName('documentation')->item(0); $this->processSniff($documentation); } }//end generate() /** * Process the documentation for a single sniff. * * Doc generators must implement this function to produce output. * * @param \DOMNode $doc The DOMNode object for the sniff. * It represents the "documentation" tag in the XML * standard file. * * @return void * @see generate() */ abstract protected function processSniff(\DOMNode $doc); }//end class PHP_CodeSniffer-3.5.4/src/Generators/HTML.php0000644000076500000240000002052213614652361020472 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Generators; use PHP_CodeSniffer\Config; class HTML extends Generator { /** * Generates the documentation for a standard. * * @return void * @see processSniff() */ public function generate() { ob_start(); $this->printHeader(); $this->printToc(); foreach ($this->docFiles as $file) { $doc = new \DOMDocument(); $doc->load($file); $documentation = $doc->getElementsByTagName('documentation')->item(0); $this->processSniff($documentation); } $this->printFooter(); $content = ob_get_contents(); ob_end_clean(); echo $content; }//end generate() /** * Print the header of the HTML page. * * @return void */ protected function printHeader() { $standard = $this->ruleset->name; echo ''.PHP_EOL; echo ' '.PHP_EOL; echo " $standard Coding Standards".PHP_EOL; echo ' '.PHP_EOL; echo ' '.PHP_EOL; echo ' '.PHP_EOL; echo "

$standard Coding Standards

".PHP_EOL; }//end printHeader() /** * Print the table of contents for the standard. * * The TOC is just an unordered list of bookmarks to sniffs on the page. * * @return void */ protected function printToc() { echo '

Table of Contents

'.PHP_EOL; echo '
    '.PHP_EOL; foreach ($this->docFiles as $file) { $doc = new \DOMDocument(); $doc->load($file); $documentation = $doc->getElementsByTagName('documentation')->item(0); $title = $this->getTitle($documentation); echo '
  • $title
    • ".PHP_EOL; } echo '
'.PHP_EOL; }//end printToc() /** * Print the footer of the HTML page. * * @return void */ protected function printFooter() { // Turn off errors so we don't get timezone warnings if people // don't have their timezone set. $errorLevel = error_reporting(0); echo '
'; echo 'Documentation generated on '.date('r'); echo ' by PHP_CodeSniffer '.Config::VERSION.''; echo '
'.PHP_EOL; error_reporting($errorLevel); echo ' '.PHP_EOL; echo ''.PHP_EOL; }//end printFooter() /** * Process the documentation for a single sniff. * * @param \DOMNode $doc The DOMNode object for the sniff. * It represents the "documentation" tag in the XML * standard file. * * @return void */ public function processSniff(\DOMNode $doc) { $title = $this->getTitle($doc); echo ' '.PHP_EOL; echo "

$title

".PHP_EOL; foreach ($doc->childNodes as $node) { if ($node->nodeName === 'standard') { $this->printTextBlock($node); } else if ($node->nodeName === 'code_comparison') { $this->printCodeComparisonBlock($node); } } }//end processSniff() /** * Print a text block found in a standard. * * @param \DOMNode $node The DOMNode object for the text block. * * @return void */ protected function printTextBlock(\DOMNode $node) { $content = trim($node->nodeValue); $content = htmlspecialchars($content); // Allow em tags only. $content = str_replace('<em>', '', $content); $content = str_replace('</em>', '', $content); echo "

$content

".PHP_EOL; }//end printTextBlock() /** * Print a code comparison block found in a standard. * * @param \DOMNode $node The DOMNode object for the code comparison block. * * @return void */ protected function printCodeComparisonBlock(\DOMNode $node) { $codeBlocks = $node->getElementsByTagName('code'); $firstTitle = $codeBlocks->item(0)->getAttribute('title'); $first = trim($codeBlocks->item(0)->nodeValue); $first = str_replace('', $first); $first = str_replace(' ', ' ', $first); $first = str_replace('', '', $first); $first = str_replace('', '', $first); $secondTitle = $codeBlocks->item(1)->getAttribute('title'); $second = trim($codeBlocks->item(1)->nodeValue); $second = str_replace('', $second); $second = str_replace(' ', ' ', $second); $second = str_replace('', '', $second); $second = str_replace('', '', $second); echo ' '.PHP_EOL; echo ' '.PHP_EOL; echo " ".PHP_EOL; echo " ".PHP_EOL; echo ' '.PHP_EOL; echo ' '.PHP_EOL; echo " ".PHP_EOL; echo " ".PHP_EOL; echo ' '.PHP_EOL; echo '
$firstTitle$secondTitle
$first$second
'.PHP_EOL; }//end printCodeComparisonBlock() }//end class PHP_CodeSniffer-3.5.4/src/Generators/Markdown.php0000644000076500000240000001046113614652361021511 0ustar gsherwoodstaff * @copyright 2014 Arroba IT * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Generators; use PHP_CodeSniffer\Config; class Markdown extends Generator { /** * Generates the documentation for a standard. * * @return void * @see processSniff() */ public function generate() { ob_start(); $this->printHeader(); foreach ($this->docFiles as $file) { $doc = new \DOMDocument(); $doc->load($file); $documentation = $doc->getElementsByTagName('documentation')->item(0); $this->processSniff($documentation); } $this->printFooter(); $content = ob_get_contents(); ob_end_clean(); echo $content; }//end generate() /** * Print the markdown header. * * @return void */ protected function printHeader() { $standard = $this->ruleset->name; echo "# $standard Coding Standard".PHP_EOL; }//end printHeader() /** * Print the markdown footer. * * @return void */ protected function printFooter() { // Turn off errors so we don't get timezone warnings if people // don't have their timezone set. error_reporting(0); echo 'Documentation generated on '.date('r'); echo ' by [PHP_CodeSniffer '.Config::VERSION.'](https://github.com/squizlabs/PHP_CodeSniffer)'.PHP_EOL; }//end printFooter() /** * Process the documentation for a single sniff. * * @param \DOMNode $doc The DOMNode object for the sniff. * It represents the "documentation" tag in the XML * standard file. * * @return void */ protected function processSniff(\DOMNode $doc) { $title = $this->getTitle($doc); echo "## $title".PHP_EOL; foreach ($doc->childNodes as $node) { if ($node->nodeName === 'standard') { $this->printTextBlock($node); } else if ($node->nodeName === 'code_comparison') { $this->printCodeComparisonBlock($node); } } }//end processSniff() /** * Print a text block found in a standard. * * @param \DOMNode $node The DOMNode object for the text block. * * @return void */ protected function printTextBlock(\DOMNode $node) { $content = trim($node->nodeValue); $content = htmlspecialchars($content); $content = str_replace('<em>', '*', $content); $content = str_replace('</em>', '*', $content); echo $content.PHP_EOL; }//end printTextBlock() /** * Print a code comparison block found in a standard. * * @param \DOMNode $node The DOMNode object for the code comparison block. * * @return void */ protected function printCodeComparisonBlock(\DOMNode $node) { $codeBlocks = $node->getElementsByTagName('code'); $firstTitle = $codeBlocks->item(0)->getAttribute('title'); $first = trim($codeBlocks->item(0)->nodeValue); $first = str_replace("\n", "\n ", $first); $first = str_replace('', '', $first); $first = str_replace('', '', $first); $secondTitle = $codeBlocks->item(1)->getAttribute('title'); $second = trim($codeBlocks->item(1)->nodeValue); $second = str_replace("\n", "\n ", $second); $second = str_replace('', '', $second); $second = str_replace('', '', $second); echo ' '.PHP_EOL; echo ' '.PHP_EOL; echo " ".PHP_EOL; echo " ".PHP_EOL; echo ' '.PHP_EOL; echo ' '.PHP_EOL; echo ''.PHP_EOL; echo ''.PHP_EOL; echo ' '.PHP_EOL; echo '
$firstTitle$secondTitle
'.PHP_EOL.PHP_EOL; echo " $first".PHP_EOL.PHP_EOL; echo ''.PHP_EOL.PHP_EOL; echo " $second".PHP_EOL.PHP_EOL; echo '
'.PHP_EOL; }//end printCodeComparisonBlock() }//end class PHP_CodeSniffer-3.5.4/src/Generators/Text.php0000644000076500000240000002006713614652361020656 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Generators; class Text extends Generator { /** * Process the documentation for a single sniff. * * @param \DOMNode $doc The DOMNode object for the sniff. * It represents the "documentation" tag in the XML * standard file. * * @return void */ public function processSniff(\DOMNode $doc) { $this->printTitle($doc); foreach ($doc->childNodes as $node) { if ($node->nodeName === 'standard') { $this->printTextBlock($node); } else if ($node->nodeName === 'code_comparison') { $this->printCodeComparisonBlock($node); } } }//end processSniff() /** * Prints the title area for a single sniff. * * @param \DOMNode $doc The DOMNode object for the sniff. * It represents the "documentation" tag in the XML * standard file. * * @return void */ protected function printTitle(\DOMNode $doc) { $title = $this->getTitle($doc); $standard = $this->ruleset->name; echo PHP_EOL; echo str_repeat('-', (strlen("$standard CODING STANDARD: $title") + 4)); echo strtoupper(PHP_EOL."| $standard CODING STANDARD: $title |".PHP_EOL); echo str_repeat('-', (strlen("$standard CODING STANDARD: $title") + 4)); echo PHP_EOL.PHP_EOL; }//end printTitle() /** * Print a text block found in a standard. * * @param \DOMNode $node The DOMNode object for the text block. * * @return void */ protected function printTextBlock(\DOMNode $node) { $text = trim($node->nodeValue); $text = str_replace('', '*', $text); $text = str_replace('', '*', $text); $nodeLines = explode("\n", $text); $lines = []; foreach ($nodeLines as $currentLine) { $currentLine = trim($currentLine); if ($currentLine === '') { // The text contained a blank line. Respect this. $lines[] = ''; continue; } $tempLine = ''; $words = explode(' ', $currentLine); foreach ($words as $word) { $currentLength = strlen($tempLine.$word); if ($currentLength < 99) { $tempLine .= $word.' '; continue; } if ($currentLength === 99 || $currentLength === 100) { // We are already at the edge, so we are done. $lines[] = $tempLine.$word; $tempLine = ''; } else { $lines[] = rtrim($tempLine); $tempLine = $word.' '; } }//end foreach if ($tempLine !== '') { $lines[] = rtrim($tempLine); } }//end foreach echo implode(PHP_EOL, $lines).PHP_EOL.PHP_EOL; }//end printTextBlock() /** * Print a code comparison block found in a standard. * * @param \DOMNode $node The DOMNode object for the code comparison block. * * @return void */ protected function printCodeComparisonBlock(\DOMNode $node) { $codeBlocks = $node->getElementsByTagName('code'); $first = trim($codeBlocks->item(0)->nodeValue); $firstTitle = $codeBlocks->item(0)->getAttribute('title'); $firstTitleLines = []; $tempTitle = ''; $words = explode(' ', $firstTitle); foreach ($words as $word) { if (strlen($tempTitle.$word) >= 45) { if (strlen($tempTitle.$word) === 45) { // Adding the extra space will push us to the edge // so we are done. $firstTitleLines[] = $tempTitle.$word; $tempTitle = ''; } else if (strlen($tempTitle.$word) === 46) { // We are already at the edge, so we are done. $firstTitleLines[] = $tempTitle.$word; $tempTitle = ''; } else { $firstTitleLines[] = $tempTitle; $tempTitle = $word.' '; } } else { $tempTitle .= $word.' '; } }//end foreach if ($tempTitle !== '') { $firstTitleLines[] = $tempTitle; } $first = str_replace('', '', $first); $first = str_replace('', '', $first); $firstLines = explode("\n", $first); $second = trim($codeBlocks->item(1)->nodeValue); $secondTitle = $codeBlocks->item(1)->getAttribute('title'); $secondTitleLines = []; $tempTitle = ''; $words = explode(' ', $secondTitle); foreach ($words as $word) { if (strlen($tempTitle.$word) >= 45) { if (strlen($tempTitle.$word) === 45) { // Adding the extra space will push us to the edge // so we are done. $secondTitleLines[] = $tempTitle.$word; $tempTitle = ''; } else if (strlen($tempTitle.$word) === 46) { // We are already at the edge, so we are done. $secondTitleLines[] = $tempTitle.$word; $tempTitle = ''; } else { $secondTitleLines[] = $tempTitle; $tempTitle = $word.' '; } } else { $tempTitle .= $word.' '; } }//end foreach if ($tempTitle !== '') { $secondTitleLines[] = $tempTitle; } $second = str_replace('', '', $second); $second = str_replace('', '', $second); $secondLines = explode("\n", $second); $maxCodeLines = max(count($firstLines), count($secondLines)); $maxTitleLines = max(count($firstTitleLines), count($secondTitleLines)); echo str_repeat('-', 41); echo ' CODE COMPARISON '; echo str_repeat('-', 42).PHP_EOL; for ($i = 0; $i < $maxTitleLines; $i++) { if (isset($firstTitleLines[$i]) === true) { $firstLineText = $firstTitleLines[$i]; } else { $firstLineText = ''; } if (isset($secondTitleLines[$i]) === true) { $secondLineText = $secondTitleLines[$i]; } else { $secondLineText = ''; } echo '| '; echo $firstLineText.str_repeat(' ', (46 - strlen($firstLineText))); echo ' | '; echo $secondLineText.str_repeat(' ', (47 - strlen($secondLineText))); echo ' |'.PHP_EOL; }//end for echo str_repeat('-', 100).PHP_EOL; for ($i = 0; $i < $maxCodeLines; $i++) { if (isset($firstLines[$i]) === true) { $firstLineText = $firstLines[$i]; } else { $firstLineText = ''; } if (isset($secondLines[$i]) === true) { $secondLineText = $secondLines[$i]; } else { $secondLineText = ''; } echo '| '; echo $firstLineText.str_repeat(' ', max(0, (47 - strlen($firstLineText)))); echo '| '; echo $secondLineText.str_repeat(' ', max(0, (48 - strlen($secondLineText)))); echo '|'.PHP_EOL; }//end for echo str_repeat('-', 100).PHP_EOL.PHP_EOL; }//end printCodeComparisonBlock() }//end class PHP_CodeSniffer-3.5.4/src/Reports/Cbf.php0000644000076500000240000001775213614652361017760 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Reports; use PHP_CodeSniffer\Exceptions\DeepExitException; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Util; class Cbf implements Report { /** * Generate a partial report for a single processed file. * * Function should return TRUE if it printed or stored data about the file * and FALSE if it ignored the file. Returning TRUE indicates that the file and * its data should be counted in the grand totals. * * @param array $report Prepared report data. * @param \PHP_CodeSniffer\File $phpcsFile The file being reported on. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * * @return bool * @throws \PHP_CodeSniffer\Exceptions\DeepExitException */ public function generateFileReport($report, File $phpcsFile, $showSources=false, $width=80) { $errors = $phpcsFile->getFixableCount(); if ($errors !== 0) { if (PHP_CODESNIFFER_VERBOSITY > 0) { ob_end_clean(); $startTime = microtime(true); echo "\t=> Fixing file: $errors/$errors violations remaining"; } $fixed = $phpcsFile->fixer->fixFile(); } if ($phpcsFile->config->stdin === true) { // Replacing STDIN, so output current file to STDOUT // even if nothing was fixed. Exit here because we // can't process any more than 1 file in this setup. $fixedContent = $phpcsFile->fixer->getContents(); throw new DeepExitException($fixedContent, 1); } if ($errors === 0) { return false; } if (PHP_CODESNIFFER_VERBOSITY > 0) { if ($fixed === false) { echo 'ERROR'; } else { echo 'DONE'; } $timeTaken = ((microtime(true) - $startTime) * 1000); if ($timeTaken < 1000) { $timeTaken = round($timeTaken); echo " in {$timeTaken}ms".PHP_EOL; } else { $timeTaken = round(($timeTaken / 1000), 2); echo " in $timeTaken secs".PHP_EOL; } } if ($fixed === true) { // The filename in the report may be truncated due to a basepath setting // but we are using it for writing here and not display, // so find the correct path if basepath is in use. $newFilename = $report['filename'].$phpcsFile->config->suffix; if ($phpcsFile->config->basepath !== null) { $newFilename = $phpcsFile->config->basepath.DIRECTORY_SEPARATOR.$newFilename; } $newContent = $phpcsFile->fixer->getContents(); file_put_contents($newFilename, $newContent); if (PHP_CODESNIFFER_VERBOSITY > 0) { if ($newFilename === $report['filename']) { echo "\t=> File was overwritten".PHP_EOL; } else { echo "\t=> Fixed file written to ".basename($newFilename).PHP_EOL; } } } if (PHP_CODESNIFFER_VERBOSITY > 0) { ob_start(); } $errorCount = $phpcsFile->getErrorCount(); $warningCount = $phpcsFile->getWarningCount(); $fixableCount = $phpcsFile->getFixableCount(); $fixedCount = ($errors - $fixableCount); echo $report['filename'].">>$errorCount>>$warningCount>>$fixableCount>>$fixedCount".PHP_EOL; return $fixed; }//end generateFileReport() /** * Prints a summary of fixed files. * * @param string $cachedData Any partial report data that was returned from * generateFileReport during the run. * @param int $totalFiles Total number of files processed during the run. * @param int $totalErrors Total number of errors found during the run. * @param int $totalWarnings Total number of warnings found during the run. * @param int $totalFixable Total number of problems that can be fixed. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * @param bool $interactive Are we running in interactive mode? * @param bool $toScreen Is the report being printed to screen? * * @return void */ public function generate( $cachedData, $totalFiles, $totalErrors, $totalWarnings, $totalFixable, $showSources=false, $width=80, $interactive=false, $toScreen=true ) { $lines = explode(PHP_EOL, $cachedData); array_pop($lines); if (empty($lines) === true) { echo PHP_EOL.'No fixable errors were found'.PHP_EOL; return; } $reportFiles = []; $maxLength = 0; $totalFixed = 0; $failures = 0; foreach ($lines as $line) { $parts = explode('>>', $line); $fileLen = strlen($parts[0]); $reportFiles[$parts[0]] = [ 'errors' => $parts[1], 'warnings' => $parts[2], 'fixable' => $parts[3], 'fixed' => $parts[4], 'strlen' => $fileLen, ]; $maxLength = max($maxLength, $fileLen); $totalFixed += $parts[4]; if ($parts[3] > 0) { $failures++; } } $width = min($width, ($maxLength + 21)); $width = max($width, 70); echo PHP_EOL."\033[1m".'PHPCBF RESULT SUMMARY'."\033[0m".PHP_EOL; echo str_repeat('-', $width).PHP_EOL; echo "\033[1m".'FILE'.str_repeat(' ', ($width - 20)).'FIXED REMAINING'."\033[0m".PHP_EOL; echo str_repeat('-', $width).PHP_EOL; foreach ($reportFiles as $file => $data) { $padding = ($width - 18 - $data['strlen']); if ($padding < 0) { $file = '...'.substr($file, (($padding * -1) + 3)); $padding = 0; } echo $file.str_repeat(' ', $padding).' '; if ($data['fixable'] > 0) { echo "\033[31mFAILED TO FIX\033[0m".PHP_EOL; continue; } $remaining = ($data['errors'] + $data['warnings']); if ($data['fixed'] !== 0) { echo $data['fixed']; echo str_repeat(' ', (7 - strlen((string) $data['fixed']))); } else { echo '0 '; } if ($remaining !== 0) { echo $remaining; } else { echo '0'; } echo PHP_EOL; }//end foreach echo str_repeat('-', $width).PHP_EOL; echo "\033[1mA TOTAL OF $totalFixed ERROR"; if ($totalFixed !== 1) { echo 'S'; } $numFiles = count($reportFiles); echo ' WERE FIXED IN '.$numFiles.' FILE'; if ($numFiles !== 1) { echo 'S'; } echo "\033[0m"; if ($failures > 0) { echo PHP_EOL.str_repeat('-', $width).PHP_EOL; echo "\033[1mPHPCBF FAILED TO FIX $failures FILE"; if ($failures !== 1) { echo 'S'; } echo "\033[0m"; } echo PHP_EOL.str_repeat('-', $width).PHP_EOL.PHP_EOL; if ($toScreen === true && $interactive === false) { Util\Timing::printRunTime(); } }//end generate() }//end class PHP_CodeSniffer-3.5.4/src/Reports/Checkstyle.php0000644000076500000240000000736113614652361021357 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Reports; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Files\File; class Checkstyle implements Report { /** * Generate a partial report for a single processed file. * * Function should return TRUE if it printed or stored data about the file * and FALSE if it ignored the file. Returning TRUE indicates that the file and * its data should be counted in the grand totals. * * @param array $report Prepared report data. * @param \PHP_CodeSniffer\File $phpcsFile The file being reported on. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * * @return bool */ public function generateFileReport($report, File $phpcsFile, $showSources=false, $width=80) { $out = new \XMLWriter; $out->openMemory(); $out->setIndent(true); if ($report['errors'] === 0 && $report['warnings'] === 0) { // Nothing to print. return false; } $out->startElement('file'); $out->writeAttribute('name', $report['filename']); foreach ($report['messages'] as $line => $lineErrors) { foreach ($lineErrors as $column => $colErrors) { foreach ($colErrors as $error) { $error['type'] = strtolower($error['type']); if ($phpcsFile->config->encoding !== 'utf-8') { $error['message'] = iconv($phpcsFile->config->encoding, 'utf-8', $error['message']); } $out->startElement('error'); $out->writeAttribute('line', $line); $out->writeAttribute('column', $column); $out->writeAttribute('severity', $error['type']); $out->writeAttribute('message', $error['message']); $out->writeAttribute('source', $error['source']); $out->endElement(); } } }//end foreach $out->endElement(); echo $out->flush(); return true; }//end generateFileReport() /** * Prints all violations for processed files, in a Checkstyle format. * * @param string $cachedData Any partial report data that was returned from * generateFileReport during the run. * @param int $totalFiles Total number of files processed during the run. * @param int $totalErrors Total number of errors found during the run. * @param int $totalWarnings Total number of warnings found during the run. * @param int $totalFixable Total number of problems that can be fixed. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * @param bool $interactive Are we running in interactive mode? * @param bool $toScreen Is the report being printed to screen? * * @return void */ public function generate( $cachedData, $totalFiles, $totalErrors, $totalWarnings, $totalFixable, $showSources=false, $width=80, $interactive=false, $toScreen=true ) { echo ''.PHP_EOL; echo ''.PHP_EOL; echo $cachedData; echo ''.PHP_EOL; }//end generate() }//end class PHP_CodeSniffer-3.5.4/src/Reports/Code.php0000644000076500000240000003131613614652361020130 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Reports; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Util; class Code implements Report { /** * Generate a partial report for a single processed file. * * Function should return TRUE if it printed or stored data about the file * and FALSE if it ignored the file. Returning TRUE indicates that the file and * its data should be counted in the grand totals. * * @param array $report Prepared report data. * @param \PHP_CodeSniffer\File $phpcsFile The file being reported on. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * * @return bool */ public function generateFileReport($report, File $phpcsFile, $showSources=false, $width=80) { if ($report['errors'] === 0 && $report['warnings'] === 0) { // Nothing to print. return false; } // How many lines to show about and below the error line. $surroundingLines = 2; $file = $report['filename']; $tokens = $phpcsFile->getTokens(); if (empty($tokens) === true) { if (PHP_CODESNIFFER_VERBOSITY === 1) { $startTime = microtime(true); echo 'CODE report is parsing '.basename($file).' '; } else if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "CODE report is forcing parse of $file".PHP_EOL; } try { $phpcsFile->parse(); } catch (\Exception $e) { // This is a second parse, so ignore exceptions. // They would have been added to the file's error list already. } if (PHP_CODESNIFFER_VERBOSITY === 1) { $timeTaken = ((microtime(true) - $startTime) * 1000); if ($timeTaken < 1000) { $timeTaken = round($timeTaken); echo "DONE in {$timeTaken}ms"; } else { $timeTaken = round(($timeTaken / 1000), 2); echo "DONE in $timeTaken secs"; } echo PHP_EOL; } $tokens = $phpcsFile->getTokens(); }//end if // Create an array that maps lines to the first token on the line. $lineTokens = []; $lastLine = 0; $stackPtr = 0; foreach ($tokens as $stackPtr => $token) { if ($token['line'] !== $lastLine) { if ($lastLine > 0) { $lineTokens[$lastLine]['end'] = ($stackPtr - 1); } $lastLine++; $lineTokens[$lastLine] = [ 'start' => $stackPtr, 'end' => null, ]; } } // Make sure the last token in the file sits on an imaginary // last line so it is easier to generate code snippets at the // end of the file. $lineTokens[$lastLine]['end'] = $stackPtr; // Determine the longest code line we will be showing. $maxSnippetLength = 0; $eolLen = strlen($phpcsFile->eolChar); foreach ($report['messages'] as $line => $lineErrors) { $startLine = max(($line - $surroundingLines), 1); $endLine = min(($line + $surroundingLines), $lastLine); $maxLineNumLength = strlen($endLine); for ($i = $startLine; $i <= $endLine; $i++) { if ($i === 1) { continue; } $lineLength = ($tokens[($lineTokens[$i]['start'] - 1)]['column'] + $tokens[($lineTokens[$i]['start'] - 1)]['length'] - $eolLen); $maxSnippetLength = max($lineLength, $maxSnippetLength); } } $maxSnippetLength += ($maxLineNumLength + 8); // Determine the longest error message we will be showing. $maxErrorLength = 0; foreach ($report['messages'] as $line => $lineErrors) { foreach ($lineErrors as $column => $colErrors) { foreach ($colErrors as $error) { $length = strlen($error['message']); if ($showSources === true) { $length += (strlen($error['source']) + 3); } $maxErrorLength = max($maxErrorLength, ($length + 1)); } } } // The padding that all lines will require that are printing an error message overflow. if ($report['warnings'] > 0) { $typeLength = 7; } else { $typeLength = 5; } $errorPadding = str_repeat(' ', ($maxLineNumLength + 7)); $errorPadding .= str_repeat(' ', $typeLength); $errorPadding .= ' '; if ($report['fixable'] > 0) { $errorPadding .= ' '; } $errorPaddingLength = strlen($errorPadding); // The maximum amount of space an error message can use. $maxErrorSpace = ($width - $errorPaddingLength); if ($showSources === true) { // Account for the chars used to print colors. $maxErrorSpace += 8; } // Figure out the max report width we need and can use. $fileLength = strlen($file); $maxWidth = max(($fileLength + 6), ($maxErrorLength + $errorPaddingLength)); $width = max(min($width, $maxWidth), $maxSnippetLength); if ($width < 70) { $width = 70; } // Print the file header. echo PHP_EOL."\033[1mFILE: "; if ($fileLength <= ($width - 6)) { echo $file; } else { echo '...'.substr($file, ($fileLength - ($width - 6))); } echo "\033[0m".PHP_EOL; echo str_repeat('-', $width).PHP_EOL; echo "\033[1m".'FOUND '.$report['errors'].' ERROR'; if ($report['errors'] !== 1) { echo 'S'; } if ($report['warnings'] > 0) { echo ' AND '.$report['warnings'].' WARNING'; if ($report['warnings'] !== 1) { echo 'S'; } } echo ' AFFECTING '.count($report['messages']).' LINE'; if (count($report['messages']) !== 1) { echo 'S'; } echo "\033[0m".PHP_EOL; foreach ($report['messages'] as $line => $lineErrors) { $startLine = max(($line - $surroundingLines), 1); $endLine = min(($line + $surroundingLines), $lastLine); $snippet = ''; if (isset($lineTokens[$startLine]) === true) { for ($i = $lineTokens[$startLine]['start']; $i <= $lineTokens[$endLine]['end']; $i++) { $snippetLine = $tokens[$i]['line']; if ($lineTokens[$snippetLine]['start'] === $i) { // Starting a new line. if ($snippetLine === $line) { $snippet .= "\033[1m".'>> '; } else { $snippet .= ' '; } $snippet .= str_repeat(' ', ($maxLineNumLength - strlen($snippetLine))); $snippet .= $snippetLine.': '; if ($snippetLine === $line) { $snippet .= "\033[0m"; } } if (isset($tokens[$i]['orig_content']) === true) { $tokenContent = $tokens[$i]['orig_content']; } else { $tokenContent = $tokens[$i]['content']; } if (strpos($tokenContent, "\t") !== false) { $token = $tokens[$i]; $token['content'] = $tokenContent; if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') { $tab = "\000"; } else { $tab = "\033[30;1m»\033[0m"; } $phpcsFile->tokenizer->replaceTabsInToken($token, $tab, "\000"); $tokenContent = $token['content']; } $tokenContent = Util\Common::prepareForOutput($tokenContent, ["\r", "\n", "\t"]); $tokenContent = str_replace("\000", ' ', $tokenContent); $underline = false; if ($snippetLine === $line && isset($lineErrors[$tokens[$i]['column']]) === true) { $underline = true; } // Underline invisible characters as well. if ($underline === true && trim($tokenContent) === '') { $snippet .= "\033[4m".' '."\033[0m".$tokenContent; } else { if ($underline === true) { $snippet .= "\033[4m"; } $snippet .= $tokenContent; if ($underline === true) { $snippet .= "\033[0m"; } } }//end for }//end if echo str_repeat('-', $width).PHP_EOL; foreach ($lineErrors as $column => $colErrors) { foreach ($colErrors as $error) { $padding = ($maxLineNumLength - strlen($line)); echo 'LINE '.str_repeat(' ', $padding).$line.': '; if ($error['type'] === 'ERROR') { echo "\033[31mERROR\033[0m"; if ($report['warnings'] > 0) { echo ' '; } } else { echo "\033[33mWARNING\033[0m"; } echo ' '; if ($report['fixable'] > 0) { echo '['; if ($error['fixable'] === true) { echo 'x'; } else { echo ' '; } echo '] '; } $message = $error['message']; $message = str_replace("\n", "\n".$errorPadding, $message); if ($showSources === true) { $message = "\033[1m".$message."\033[0m".' ('.$error['source'].')'; } $errorMsg = wordwrap( $message, $maxErrorSpace, PHP_EOL.$errorPadding ); echo $errorMsg.PHP_EOL; }//end foreach }//end foreach echo str_repeat('-', $width).PHP_EOL; echo rtrim($snippet).PHP_EOL; }//end foreach echo str_repeat('-', $width).PHP_EOL; if ($report['fixable'] > 0) { echo "\033[1m".'PHPCBF CAN FIX THE '.$report['fixable'].' MARKED SNIFF VIOLATIONS AUTOMATICALLY'."\033[0m".PHP_EOL; echo str_repeat('-', $width).PHP_EOL; } return true; }//end generateFileReport() /** * Prints all errors and warnings for each file processed. * * @param string $cachedData Any partial report data that was returned from * generateFileReport during the run. * @param int $totalFiles Total number of files processed during the run. * @param int $totalErrors Total number of errors found during the run. * @param int $totalWarnings Total number of warnings found during the run. * @param int $totalFixable Total number of problems that can be fixed. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * @param bool $interactive Are we running in interactive mode? * @param bool $toScreen Is the report being printed to screen? * * @return void */ public function generate( $cachedData, $totalFiles, $totalErrors, $totalWarnings, $totalFixable, $showSources=false, $width=80, $interactive=false, $toScreen=true ) { if ($cachedData === '') { return; } echo $cachedData; if ($toScreen === true && $interactive === false) { Util\Timing::printRunTime(); } }//end generate() }//end class PHP_CodeSniffer-3.5.4/src/Reports/Csv.php0000644000076500000240000000616613614652361020016 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Reports; use PHP_CodeSniffer\Files\File; class Csv implements Report { /** * Generate a partial report for a single processed file. * * Function should return TRUE if it printed or stored data about the file * and FALSE if it ignored the file. Returning TRUE indicates that the file and * its data should be counted in the grand totals. * * @param array $report Prepared report data. * @param \PHP_CodeSniffer\File $phpcsFile The file being reported on. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * * @return bool */ public function generateFileReport($report, File $phpcsFile, $showSources=false, $width=80) { if ($report['errors'] === 0 && $report['warnings'] === 0) { // Nothing to print. return false; } foreach ($report['messages'] as $line => $lineErrors) { foreach ($lineErrors as $column => $colErrors) { foreach ($colErrors as $error) { $filename = str_replace('"', '\"', $report['filename']); $message = str_replace('"', '\"', $error['message']); $type = strtolower($error['type']); $source = $error['source']; $severity = $error['severity']; $fixable = (int) $error['fixable']; echo "\"$filename\",$line,$column,$type,\"$message\",$source,$severity,$fixable".PHP_EOL; } } } return true; }//end generateFileReport() /** * Generates a csv report. * * @param string $cachedData Any partial report data that was returned from * generateFileReport during the run. * @param int $totalFiles Total number of files processed during the run. * @param int $totalErrors Total number of errors found during the run. * @param int $totalWarnings Total number of warnings found during the run. * @param int $totalFixable Total number of problems that can be fixed. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * @param bool $interactive Are we running in interactive mode? * @param bool $toScreen Is the report being printed to screen? * * @return void */ public function generate( $cachedData, $totalFiles, $totalErrors, $totalWarnings, $totalFixable, $showSources=false, $width=80, $interactive=false, $toScreen=true ) { echo 'File,Line,Column,Type,Message,Source,Severity,Fixable'.PHP_EOL; echo $cachedData; }//end generate() }//end class PHP_CodeSniffer-3.5.4/src/Reports/Diff.php0000644000076500000240000001002513614652361020120 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Reports; use PHP_CodeSniffer\Files\File; class Diff implements Report { /** * Generate a partial report for a single processed file. * * Function should return TRUE if it printed or stored data about the file * and FALSE if it ignored the file. Returning TRUE indicates that the file and * its data should be counted in the grand totals. * * @param array $report Prepared report data. * @param \PHP_CodeSniffer\File $phpcsFile The file being reported on. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * * @return bool */ public function generateFileReport($report, File $phpcsFile, $showSources=false, $width=80) { $errors = $phpcsFile->getFixableCount(); if ($errors === 0) { return false; } $phpcsFile->disableCaching(); $tokens = $phpcsFile->getTokens(); if (empty($tokens) === true) { if (PHP_CODESNIFFER_VERBOSITY === 1) { $startTime = microtime(true); echo 'DIFF report is parsing '.basename($report['filename']).' '; } else if (PHP_CODESNIFFER_VERBOSITY > 1) { echo 'DIFF report is forcing parse of '.$report['filename'].PHP_EOL; } $phpcsFile->parse(); if (PHP_CODESNIFFER_VERBOSITY === 1) { $timeTaken = ((microtime(true) - $startTime) * 1000); if ($timeTaken < 1000) { $timeTaken = round($timeTaken); echo "DONE in {$timeTaken}ms"; } else { $timeTaken = round(($timeTaken / 1000), 2); echo "DONE in $timeTaken secs"; } echo PHP_EOL; } $phpcsFile->fixer->startFile($phpcsFile); }//end if if (PHP_CODESNIFFER_VERBOSITY > 1) { ob_end_clean(); echo "\t*** START FILE FIXING ***".PHP_EOL; } $fixed = $phpcsFile->fixer->fixFile(); if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t*** END FILE FIXING ***".PHP_EOL; ob_start(); } if ($fixed === false) { return false; } $diff = $phpcsFile->fixer->generateDiff(); if ($diff === '') { // Nothing to print. return false; } echo $diff.PHP_EOL; return true; }//end generateFileReport() /** * Prints all errors and warnings for each file processed. * * @param string $cachedData Any partial report data that was returned from * generateFileReport during the run. * @param int $totalFiles Total number of files processed during the run. * @param int $totalErrors Total number of errors found during the run. * @param int $totalWarnings Total number of warnings found during the run. * @param int $totalFixable Total number of problems that can be fixed. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * @param bool $interactive Are we running in interactive mode? * @param bool $toScreen Is the report being printed to screen? * * @return void */ public function generate( $cachedData, $totalFiles, $totalErrors, $totalWarnings, $totalFixable, $showSources=false, $width=80, $interactive=false, $toScreen=true ) { echo $cachedData; if ($toScreen === true && $cachedData !== '') { echo PHP_EOL; } }//end generate() }//end class PHP_CodeSniffer-3.5.4/src/Reports/Emacs.php0000644000076500000240000000564513614652361020314 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Reports; use PHP_CodeSniffer\Files\File; class Emacs implements Report { /** * Generate a partial report for a single processed file. * * Function should return TRUE if it printed or stored data about the file * and FALSE if it ignored the file. Returning TRUE indicates that the file and * its data should be counted in the grand totals. * * @param array $report Prepared report data. * @param \PHP_CodeSniffer\File $phpcsFile The file being reported on. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * * @return bool */ public function generateFileReport($report, File $phpcsFile, $showSources=false, $width=80) { if ($report['errors'] === 0 && $report['warnings'] === 0) { // Nothing to print. return false; } foreach ($report['messages'] as $line => $lineErrors) { foreach ($lineErrors as $column => $colErrors) { foreach ($colErrors as $error) { $message = $error['message']; if ($showSources === true) { $message .= ' ('.$error['source'].')'; } $type = strtolower($error['type']); echo $report['filename'].':'.$line.':'.$column.': '.$type.' - '.$message.PHP_EOL; } } } return true; }//end generateFileReport() /** * Generates an emacs report. * * @param string $cachedData Any partial report data that was returned from * generateFileReport during the run. * @param int $totalFiles Total number of files processed during the run. * @param int $totalErrors Total number of errors found during the run. * @param int $totalWarnings Total number of warnings found during the run. * @param int $totalFixable Total number of problems that can be fixed. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * @param bool $interactive Are we running in interactive mode? * @param bool $toScreen Is the report being printed to screen? * * @return void */ public function generate( $cachedData, $totalFiles, $totalErrors, $totalWarnings, $totalFixable, $showSources=false, $width=80, $interactive=false, $toScreen=true ) { echo $cachedData; }//end generate() }//end class PHP_CodeSniffer-3.5.4/src/Reports/Full.php0000644000076500000240000001722013614652361020156 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Reports; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Util; class Full implements Report { /** * Generate a partial report for a single processed file. * * Function should return TRUE if it printed or stored data about the file * and FALSE if it ignored the file. Returning TRUE indicates that the file and * its data should be counted in the grand totals. * * @param array $report Prepared report data. * @param \PHP_CodeSniffer\File $phpcsFile The file being reported on. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * * @return bool */ public function generateFileReport($report, File $phpcsFile, $showSources=false, $width=80) { if ($report['errors'] === 0 && $report['warnings'] === 0) { // Nothing to print. return false; } // The length of the word ERROR or WARNING; used for padding. if ($report['warnings'] > 0) { $typeLength = 7; } else { $typeLength = 5; } // Work out the max line number length for formatting. $maxLineNumLength = max(array_map('strlen', array_keys($report['messages']))); // The padding that all lines will require that are // printing an error message overflow. $paddingLine2 = str_repeat(' ', ($maxLineNumLength + 1)); $paddingLine2 .= ' | '; $paddingLine2 .= str_repeat(' ', $typeLength); $paddingLine2 .= ' | '; if ($report['fixable'] > 0) { $paddingLine2 .= ' '; } $paddingLength = strlen($paddingLine2); // Make sure the report width isn't too big. $maxErrorLength = 0; foreach ($report['messages'] as $line => $lineErrors) { foreach ($lineErrors as $column => $colErrors) { foreach ($colErrors as $error) { $length = strlen($error['message']); if ($showSources === true) { $length += (strlen($error['source']) + 3); } $maxErrorLength = max($maxErrorLength, ($length + 1)); } } } $file = $report['filename']; $fileLength = strlen($file); $maxWidth = max(($fileLength + 6), ($maxErrorLength + $paddingLength)); $width = min($width, $maxWidth); if ($width < 70) { $width = 70; } echo PHP_EOL."\033[1mFILE: "; if ($fileLength <= ($width - 6)) { echo $file; } else { echo '...'.substr($file, ($fileLength - ($width - 6))); } echo "\033[0m".PHP_EOL; echo str_repeat('-', $width).PHP_EOL; echo "\033[1m".'FOUND '.$report['errors'].' ERROR'; if ($report['errors'] !== 1) { echo 'S'; } if ($report['warnings'] > 0) { echo ' AND '.$report['warnings'].' WARNING'; if ($report['warnings'] !== 1) { echo 'S'; } } echo ' AFFECTING '.count($report['messages']).' LINE'; if (count($report['messages']) !== 1) { echo 'S'; } echo "\033[0m".PHP_EOL; echo str_repeat('-', $width).PHP_EOL; // The maximum amount of space an error message can use. $maxErrorSpace = ($width - $paddingLength - 1); foreach ($report['messages'] as $line => $lineErrors) { foreach ($lineErrors as $column => $colErrors) { foreach ($colErrors as $error) { $message = $error['message']; $msgLines = [$message]; if (strpos($message, "\n") !== false) { $msgLines = explode("\n", $message); } $errorMsg = ''; $lastLine = (count($msgLines) - 1); foreach ($msgLines as $k => $msgLine) { if ($k === 0) { if ($showSources === true) { $errorMsg .= "\033[1m"; } } else { $errorMsg .= PHP_EOL.$paddingLine2; } if ($k === $lastLine && $showSources === true) { $msgLine .= "\033[0m".' ('.$error['source'].')'; } $errorMsg .= wordwrap( $msgLine, $maxErrorSpace, PHP_EOL.$paddingLine2 ); } // The padding that goes on the front of the line. $padding = ($maxLineNumLength - strlen($line)); echo ' '.str_repeat(' ', $padding).$line.' | '; if ($error['type'] === 'ERROR') { echo "\033[31mERROR\033[0m"; if ($report['warnings'] > 0) { echo ' '; } } else { echo "\033[33mWARNING\033[0m"; } echo ' | '; if ($report['fixable'] > 0) { echo '['; if ($error['fixable'] === true) { echo 'x'; } else { echo ' '; } echo '] '; } echo $errorMsg.PHP_EOL; }//end foreach }//end foreach }//end foreach echo str_repeat('-', $width).PHP_EOL; if ($report['fixable'] > 0) { echo "\033[1m".'PHPCBF CAN FIX THE '.$report['fixable'].' MARKED SNIFF VIOLATIONS AUTOMATICALLY'."\033[0m".PHP_EOL; echo str_repeat('-', $width).PHP_EOL; } echo PHP_EOL; return true; }//end generateFileReport() /** * Prints all errors and warnings for each file processed. * * @param string $cachedData Any partial report data that was returned from * generateFileReport during the run. * @param int $totalFiles Total number of files processed during the run. * @param int $totalErrors Total number of errors found during the run. * @param int $totalWarnings Total number of warnings found during the run. * @param int $totalFixable Total number of problems that can be fixed. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * @param bool $interactive Are we running in interactive mode? * @param bool $toScreen Is the report being printed to screen? * * @return void */ public function generate( $cachedData, $totalFiles, $totalErrors, $totalWarnings, $totalFixable, $showSources=false, $width=80, $interactive=false, $toScreen=true ) { if ($cachedData === '') { return; } echo $cachedData; if ($toScreen === true && $interactive === false) { Util\Timing::printRunTime(); } }//end generate() }//end class PHP_CodeSniffer-3.5.4/src/Reports/Gitblame.php0000644000076500000240000000422513614652361021001 0ustar gsherwoodstaff * @author Greg Sherwood * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Reports; use PHP_CodeSniffer\Exceptions\DeepExitException; class Gitblame extends VersionControl { /** * The name of the report we want in the output * * @var string */ protected $reportName = 'GIT'; /** * Extract the author from a blame line. * * @param string $line Line to parse. * * @return mixed string or false if impossible to recover. */ protected function getAuthor($line) { $blameParts = []; $line = preg_replace('|\s+|', ' ', $line); preg_match( '|\(.+[0-9]{4}-[0-9]{2}-[0-9]{2}\s+[0-9]+\)|', $line, $blameParts ); if (isset($blameParts[0]) === false) { return false; } $parts = explode(' ', $blameParts[0]); if (count($parts) < 2) { return false; } $parts = array_slice($parts, 0, (count($parts) - 2)); $author = preg_replace('|\(|', '', implode(' ', $parts)); return $author; }//end getAuthor() /** * Gets the blame output. * * @param string $filename File to blame. * * @return array * @throws \PHP_CodeSniffer\Exceptions\DeepExitException */ protected function getBlameContent($filename) { $cwd = getcwd(); chdir(dirname($filename)); $command = 'git blame --date=short "'.$filename.'" 2>&1'; $handle = popen($command, 'r'); if ($handle === false) { $error = 'ERROR: Could not execute "'.$command.'"'.PHP_EOL.PHP_EOL; throw new DeepExitException($error, 3); } $rawContent = stream_get_contents($handle); fclose($handle); $blames = explode("\n", $rawContent); chdir($cwd); return $blames; }//end getBlameContent() }//end class PHP_CodeSniffer-3.5.4/src/Reports/Hgblame.php0000644000076500000240000000535213614652361020616 0ustar gsherwoodstaff * @author Greg Sherwood * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Reports; use PHP_CodeSniffer\Exceptions\DeepExitException; class Hgblame extends VersionControl { /** * The name of the report we want in the output * * @var string */ protected $reportName = 'MERCURIAL'; /** * Extract the author from a blame line. * * @param string $line Line to parse. * * @return mixed string or false if impossible to recover. */ protected function getAuthor($line) { $blameParts = []; $line = preg_replace('|\s+|', ' ', $line); preg_match( '|(.+[0-9]{2}:[0-9]{2}:[0-9]{2}\s[0-9]{4}\s.[0-9]{4}:)|', $line, $blameParts ); if (isset($blameParts[0]) === false) { return false; } $parts = explode(' ', $blameParts[0]); if (count($parts) < 6) { return false; } $parts = array_slice($parts, 0, (count($parts) - 6)); return trim(preg_replace('|<.+>|', '', implode(' ', $parts))); }//end getAuthor() /** * Gets the blame output. * * @param string $filename File to blame. * * @return array * @throws \PHP_CodeSniffer\Exceptions\DeepExitException */ protected function getBlameContent($filename) { $cwd = getcwd(); $fileParts = explode(DIRECTORY_SEPARATOR, $filename); $found = false; $location = ''; while (empty($fileParts) === false) { array_pop($fileParts); $location = implode(DIRECTORY_SEPARATOR, $fileParts); if (is_dir($location.DIRECTORY_SEPARATOR.'.hg') === true) { $found = true; break; } } if ($found === true) { chdir($location); } else { $error = 'ERROR: Could not locate .hg directory '.PHP_EOL.PHP_EOL; throw new DeepExitException($error, 3); } $command = 'hg blame -u -d -v "'.$filename.'" 2>&1'; $handle = popen($command, 'r'); if ($handle === false) { $error = 'ERROR: Could not execute "'.$command.'"'.PHP_EOL.PHP_EOL; throw new DeepExitException($error, 3); } $rawContent = stream_get_contents($handle); fclose($handle); $blames = explode("\n", $rawContent); chdir($cwd); return $blames; }//end getBlameContent() }//end class PHP_CodeSniffer-3.5.4/src/Reports/Info.php0000644000076500000240000001306513614652361020152 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Reports; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Util\Timing; class Info implements Report { /** * Generate a partial report for a single processed file. * * Function should return TRUE if it printed or stored data about the file * and FALSE if it ignored the file. Returning TRUE indicates that the file and * its data should be counted in the grand totals. * * @param array $report Prepared report data. * @param \PHP_CodeSniffer\File $phpcsFile The file being reported on. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * * @return bool */ public function generateFileReport($report, File $phpcsFile, $showSources=false, $width=80) { $metrics = $phpcsFile->getMetrics(); foreach ($metrics as $metric => $data) { foreach ($data['values'] as $value => $count) { echo "$metric>>$value>>$count".PHP_EOL; } } return true; }//end generateFileReport() /** * Prints the source of all errors and warnings. * * @param string $cachedData Any partial report data that was returned from * generateFileReport during the run. * @param int $totalFiles Total number of files processed during the run. * @param int $totalErrors Total number of errors found during the run. * @param int $totalWarnings Total number of warnings found during the run. * @param int $totalFixable Total number of problems that can be fixed. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * @param bool $interactive Are we running in interactive mode? * @param bool $toScreen Is the report being printed to screen? * * @return void */ public function generate( $cachedData, $totalFiles, $totalErrors, $totalWarnings, $totalFixable, $showSources=false, $width=80, $interactive=false, $toScreen=true ) { $lines = explode(PHP_EOL, $cachedData); array_pop($lines); if (empty($lines) === true) { return; } $metrics = []; foreach ($lines as $line) { $parts = explode('>>', $line); $metric = $parts[0]; $value = $parts[1]; $count = $parts[2]; if (isset($metrics[$metric]) === false) { $metrics[$metric] = []; } if (isset($metrics[$metric][$value]) === false) { $metrics[$metric][$value] = $count; } else { $metrics[$metric][$value] += $count; } } ksort($metrics); echo PHP_EOL."\033[1m".'PHP CODE SNIFFER INFORMATION REPORT'."\033[0m".PHP_EOL; echo str_repeat('-', 70).PHP_EOL; foreach ($metrics as $metric => $values) { if (count($values) === 1) { $count = reset($values); $value = key($values); echo "$metric: \033[4m$value\033[0m [$count/$count, 100%]".PHP_EOL; } else { $totalCount = 0; $valueWidth = 0; foreach ($values as $value => $count) { $totalCount += $count; $valueWidth = max($valueWidth, strlen($value)); } // Length of the total string, plus however many // thousands separators there are. $countWidth = (strlen($totalCount) + floor($countWidth / 3)); // Account for 'total' line. $valueWidth = max(5, $valueWidth); echo "$metric:".PHP_EOL; ksort($values, SORT_NATURAL); arsort($values); $percentPrefixWidth = 0; $percentWidth = 6; foreach ($values as $value => $count) { $percent = round(($count / $totalCount * 100), 2); $percentPrefix = ''; if ($percent === 0.00) { $percent = 0.01; $percentPrefix = '<'; $percentPrefixWidth = 2; $percentWidth = 4; } printf( "\t%-{$valueWidth}s => %{$countWidth}s (%{$percentPrefixWidth}s%{$percentWidth}.2f%%)".PHP_EOL, $value, number_format($count), $percentPrefix, $percent ); } echo "\t".str_repeat('-', ($valueWidth + $countWidth + 15)).PHP_EOL; printf( "\t%-{$valueWidth}s => %{$countWidth}s (100.00%%)".PHP_EOL, 'total', number_format($totalCount) ); }//end if echo PHP_EOL; }//end foreach echo str_repeat('-', 70).PHP_EOL; if ($toScreen === true && $interactive === false) { Timing::printRunTime(); } }//end generate() }//end class PHP_CodeSniffer-3.5.4/src/Reports/Json.php0000644000076500000240000000735413614652361020174 0ustar gsherwoodstaff * @author Greg Sherwood * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Reports; use PHP_CodeSniffer\Files\File; class Json implements Report { /** * Generate a partial report for a single processed file. * * Function should return TRUE if it printed or stored data about the file * and FALSE if it ignored the file. Returning TRUE indicates that the file and * its data should be counted in the grand totals. * * @param array $report Prepared report data. * @param \PHP_CodeSniffer\File $phpcsFile The file being reported on. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * * @return bool */ public function generateFileReport($report, File $phpcsFile, $showSources=false, $width=80) { $filename = str_replace('\\', '\\\\', $report['filename']); $filename = str_replace('"', '\"', $filename); $filename = str_replace('/', '\/', $filename); echo '"'.$filename.'":{'; echo '"errors":'.$report['errors'].',"warnings":'.$report['warnings'].',"messages":['; $messages = ''; foreach ($report['messages'] as $line => $lineErrors) { foreach ($lineErrors as $column => $colErrors) { foreach ($colErrors as $error) { $error['message'] = str_replace("\n", '\n', $error['message']); $error['message'] = str_replace("\r", '\r', $error['message']); $error['message'] = str_replace("\t", '\t', $error['message']); $fixable = false; if ($error['fixable'] === true) { $fixable = true; } $messagesObject = (object) $error; $messagesObject->line = $line; $messagesObject->column = $column; $messagesObject->fixable = $fixable; $messages .= json_encode($messagesObject).","; } } }//end foreach echo rtrim($messages, ','); echo ']},'; return true; }//end generateFileReport() /** * Generates a JSON report. * * @param string $cachedData Any partial report data that was returned from * generateFileReport during the run. * @param int $totalFiles Total number of files processed during the run. * @param int $totalErrors Total number of errors found during the run. * @param int $totalWarnings Total number of warnings found during the run. * @param int $totalFixable Total number of problems that can be fixed. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * @param bool $interactive Are we running in interactive mode? * @param bool $toScreen Is the report being printed to screen? * * @return void */ public function generate( $cachedData, $totalFiles, $totalErrors, $totalWarnings, $totalFixable, $showSources=false, $width=80, $interactive=false, $toScreen=true ) { echo '{"totals":{"errors":'.$totalErrors.',"warnings":'.$totalWarnings.',"fixable":'.$totalFixable.'},"files":{'; echo rtrim($cachedData, ','); echo "}}".PHP_EOL; }//end generate() }//end class PHP_CodeSniffer-3.5.4/src/Reports/Junit.php0000644000076500000240000001125013614652361020342 0ustar gsherwoodstaff * @author Greg Sherwood * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Reports; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Files\File; class Junit implements Report { /** * Generate a partial report for a single processed file. * * Function should return TRUE if it printed or stored data about the file * and FALSE if it ignored the file. Returning TRUE indicates that the file and * its data should be counted in the grand totals. * * @param array $report Prepared report data. * @param \PHP_CodeSniffer\File $phpcsFile The file being reported on. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * * @return bool */ public function generateFileReport($report, File $phpcsFile, $showSources=false, $width=80) { $out = new \XMLWriter; $out->openMemory(); $out->setIndent(true); $out->startElement('testsuite'); $out->writeAttribute('name', $report['filename']); $out->writeAttribute('errors', 0); if (count($report['messages']) === 0) { $out->writeAttribute('tests', 1); $out->writeAttribute('failures', 0); $out->startElement('testcase'); $out->writeAttribute('name', $report['filename']); $out->endElement(); } else { $failures = ($report['errors'] + $report['warnings']); $out->writeAttribute('tests', $failures); $out->writeAttribute('failures', $failures); foreach ($report['messages'] as $line => $lineErrors) { foreach ($lineErrors as $column => $colErrors) { foreach ($colErrors as $error) { $out->startElement('testcase'); $out->writeAttribute('name', $error['source'].' at '.$report['filename']." ($line:$column)"); $error['type'] = strtolower($error['type']); if ($phpcsFile->config->encoding !== 'utf-8') { $error['message'] = iconv($phpcsFile->config->encoding, 'utf-8', $error['message']); } $out->startElement('failure'); $out->writeAttribute('type', $error['type']); $out->writeAttribute('message', $error['message']); $out->endElement(); $out->endElement(); } } } }//end if $out->endElement(); echo $out->flush(); return true; }//end generateFileReport() /** * Prints all violations for processed files, in a proprietary XML format. * * @param string $cachedData Any partial report data that was returned from * generateFileReport during the run. * @param int $totalFiles Total number of files processed during the run. * @param int $totalErrors Total number of errors found during the run. * @param int $totalWarnings Total number of warnings found during the run. * @param int $totalFixable Total number of problems that can be fixed. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * @param bool $interactive Are we running in interactive mode? * @param bool $toScreen Is the report being printed to screen? * * @return void */ public function generate( $cachedData, $totalFiles, $totalErrors, $totalWarnings, $totalFixable, $showSources=false, $width=80, $interactive=false, $toScreen=true ) { // Figure out the total number of tests. $tests = 0; $matches = []; preg_match_all('/tests="([0-9]+)"/', $cachedData, $matches); if (isset($matches[1]) === true) { foreach ($matches[1] as $match) { $tests += $match; } } $failures = ($totalErrors + $totalWarnings); echo ''.PHP_EOL; echo ''.PHP_EOL; echo $cachedData; echo ''.PHP_EOL; }//end generate() }//end class PHP_CodeSniffer-3.5.4/src/Reports/Notifysend.php0000644000076500000240000001507713614652361021406 0ustar gsherwoodstaff * @author Greg Sherwood * @copyright 2012-2014 Christian Weiske * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Reports; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Files\File; class Notifysend implements Report { /** * Notification timeout in milliseconds. * * @var integer */ protected $timeout = 3000; /** * Path to notify-send command. * * @var string */ protected $path = 'notify-send'; /** * Show "ok, all fine" messages. * * @var boolean */ protected $showOk = true; /** * Version of installed notify-send executable. * * @var string */ protected $version = null; /** * Load configuration data. */ public function __construct() { $path = Config::getExecutablePath('notifysend'); if ($path !== null) { $this->path = escapeshellcmd($path); } $timeout = Config::getConfigData('notifysend_timeout'); if ($timeout !== null) { $this->timeout = (int) $timeout; } $showOk = Config::getConfigData('notifysend_showok'); if ($showOk !== null) { $this->showOk = (bool) $showOk; } $this->version = str_replace( 'notify-send ', '', exec($this->path.' --version') ); }//end __construct() /** * Generate a partial report for a single processed file. * * Function should return TRUE if it printed or stored data about the file * and FALSE if it ignored the file. Returning TRUE indicates that the file and * its data should be counted in the grand totals. * * @param array $report Prepared report data. * @param \PHP_CodeSniffer\File $phpcsFile The file being reported on. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * * @return bool */ public function generateFileReport($report, File $phpcsFile, $showSources=false, $width=80) { echo $report['filename'].PHP_EOL; // We want this file counted in the total number // of checked files even if it has no errors. return true; }//end generateFileReport() /** * Generates a summary of errors and warnings for each file processed. * * @param string $cachedData Any partial report data that was returned from * generateFileReport during the run. * @param int $totalFiles Total number of files processed during the run. * @param int $totalErrors Total number of errors found during the run. * @param int $totalWarnings Total number of warnings found during the run. * @param int $totalFixable Total number of problems that can be fixed. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * @param bool $interactive Are we running in interactive mode? * @param bool $toScreen Is the report being printed to screen? * * @return void */ public function generate( $cachedData, $totalFiles, $totalErrors, $totalWarnings, $totalFixable, $showSources=false, $width=80, $interactive=false, $toScreen=true ) { $checkedFiles = explode(PHP_EOL, trim($cachedData)); $msg = $this->generateMessage($checkedFiles, $totalErrors, $totalWarnings); if ($msg === null) { if ($this->showOk === true) { $this->notifyAllFine(); } } else { $this->notifyErrors($msg); } }//end generate() /** * Generate the error message to show to the user. * * @param string[] $checkedFiles The files checked during the run. * @param int $totalErrors Total number of errors found during the run. * @param int $totalWarnings Total number of warnings found during the run. * * @return string Error message or NULL if no error/warning found. */ protected function generateMessage($checkedFiles, $totalErrors, $totalWarnings) { if ($totalErrors === 0 && $totalWarnings === 0) { // Nothing to print. return null; } $totalFiles = count($checkedFiles); $msg = ''; if ($totalFiles > 1) { $msg .= 'Checked '.$totalFiles.' files'.PHP_EOL; } else { $msg .= $checkedFiles[0].PHP_EOL; } if ($totalWarnings > 0) { $msg .= $totalWarnings.' warnings'.PHP_EOL; } if ($totalErrors > 0) { $msg .= $totalErrors.' errors'.PHP_EOL; } return $msg; }//end generateMessage() /** * Tell the user that all is fine and no error/warning has been found. * * @return void */ protected function notifyAllFine() { $cmd = $this->getBasicCommand(); $cmd .= ' -i info'; $cmd .= ' "PHP CodeSniffer: Ok"'; $cmd .= ' "All fine"'; exec($cmd); }//end notifyAllFine() /** * Tell the user that errors/warnings have been found. * * @param string $msg Message to display. * * @return void */ protected function notifyErrors($msg) { $cmd = $this->getBasicCommand(); $cmd .= ' -i error'; $cmd .= ' "PHP CodeSniffer: Error"'; $cmd .= ' '.escapeshellarg(trim($msg)); exec($cmd); }//end notifyErrors() /** * Generate and return the basic notify-send command string to execute. * * @return string Shell command with common parameters. */ protected function getBasicCommand() { $cmd = $this->path; $cmd .= ' --category dev.validate'; $cmd .= ' -h int:transient:1'; $cmd .= ' -t '.(int) $this->timeout; if (version_compare($this->version, '0.7.3', '>=') === true) { $cmd .= ' -a phpcs'; } return $cmd; }//end getBasicCommand() }//end class PHP_CodeSniffer-3.5.4/src/Reports/Report.php0000644000076500000240000000421613614652361020530 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Reports; use PHP_CodeSniffer\Files\File; interface Report { /** * Generate a partial report for a single processed file. * * Function should return TRUE if it printed or stored data about the file * and FALSE if it ignored the file. Returning TRUE indicates that the file and * its data should be counted in the grand totals. * * @param array $report Prepared report data. * @param \PHP_CodeSniffer\File $phpcsFile The file being reported on. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * * @return bool */ public function generateFileReport($report, File $phpcsFile, $showSources=false, $width=80); /** * Generate the actual report. * * @param string $cachedData Any partial report data that was returned from * generateFileReport during the run. * @param int $totalFiles Total number of files processed during the run. * @param int $totalErrors Total number of errors found during the run. * @param int $totalWarnings Total number of warnings found during the run. * @param int $totalFixable Total number of problems that can be fixed. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * @param bool $interactive Are we running in interactive mode? * @param bool $toScreen Is the report being printed to screen? * * @return void */ public function generate( $cachedData, $totalFiles, $totalErrors, $totalWarnings, $totalFixable, $showSources=false, $width=80, $interactive=false, $toScreen=true ); }//end interface PHP_CodeSniffer-3.5.4/src/Reports/Source.php0000644000076500000240000002523013614652361020514 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Reports; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Util\Timing; class Source implements Report { /** * Generate a partial report for a single processed file. * * Function should return TRUE if it printed or stored data about the file * and FALSE if it ignored the file. Returning TRUE indicates that the file and * its data should be counted in the grand totals. * * @param array $report Prepared report data. * @param \PHP_CodeSniffer\File $phpcsFile The file being reported on. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * * @return bool */ public function generateFileReport($report, File $phpcsFile, $showSources=false, $width=80) { if ($report['errors'] === 0 && $report['warnings'] === 0) { // Nothing to print. return false; } $sources = []; foreach ($report['messages'] as $line => $lineErrors) { foreach ($lineErrors as $column => $colErrors) { foreach ($colErrors as $error) { $src = $error['source']; if (isset($sources[$src]) === false) { $sources[$src] = [ 'fixable' => (int) $error['fixable'], 'count' => 1, ]; } else { $sources[$src]['count']++; } } } } foreach ($sources as $source => $data) { echo $source.'>>'.$data['fixable'].'>>'.$data['count'].PHP_EOL; } return true; }//end generateFileReport() /** * Prints the source of all errors and warnings. * * @param string $cachedData Any partial report data that was returned from * generateFileReport during the run. * @param int $totalFiles Total number of files processed during the run. * @param int $totalErrors Total number of errors found during the run. * @param int $totalWarnings Total number of warnings found during the run. * @param int $totalFixable Total number of problems that can be fixed. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * @param bool $interactive Are we running in interactive mode? * @param bool $toScreen Is the report being printed to screen? * * @return void */ public function generate( $cachedData, $totalFiles, $totalErrors, $totalWarnings, $totalFixable, $showSources=false, $width=80, $interactive=false, $toScreen=true ) { $lines = explode(PHP_EOL, $cachedData); array_pop($lines); if (empty($lines) === true) { return; } $sources = []; $maxLength = 0; foreach ($lines as $line) { $parts = explode('>>', $line); $source = $parts[0]; $fixable = (bool) $parts[1]; $count = $parts[2]; if (isset($sources[$source]) === false) { if ($showSources === true) { $parts = null; $sniff = $source; } else { $parts = explode('.', $source); if ($parts[0] === 'Internal') { $parts[2] = $parts[1]; $parts[1] = ''; } $parts[1] = $this->makeFriendlyName($parts[1]); $sniff = $this->makeFriendlyName($parts[2]); if (isset($parts[3]) === true) { $name = $this->makeFriendlyName($parts[3]); $name[0] = strtolower($name[0]); $sniff .= ' '.$name; unset($parts[3]); } $parts[2] = $sniff; }//end if $maxLength = max($maxLength, strlen($sniff)); $sources[$source] = [ 'count' => $count, 'fixable' => $fixable, 'parts' => $parts, ]; } else { $sources[$source]['count'] += $count; }//end if }//end foreach if ($showSources === true) { $width = min($width, ($maxLength + 11)); } else { $width = min($width, ($maxLength + 41)); } $width = max($width, 70); // Sort the data based on counts and source code. $sourceCodes = array_keys($sources); $counts = []; foreach ($sources as $source => $data) { $counts[$source] = $data['count']; } array_multisort($counts, SORT_DESC, $sourceCodes, SORT_ASC, SORT_NATURAL, $sources); echo PHP_EOL."\033[1mPHP CODE SNIFFER VIOLATION SOURCE SUMMARY\033[0m".PHP_EOL; echo str_repeat('-', $width).PHP_EOL."\033[1m"; if ($showSources === true) { if ($totalFixable > 0) { echo ' SOURCE'.str_repeat(' ', ($width - 15)).'COUNT'.PHP_EOL; } else { echo 'SOURCE'.str_repeat(' ', ($width - 11)).'COUNT'.PHP_EOL; } } else { if ($totalFixable > 0) { echo ' STANDARD CATEGORY SNIFF'.str_repeat(' ', ($width - 44)).'COUNT'.PHP_EOL; } else { echo 'STANDARD CATEGORY SNIFF'.str_repeat(' ', ($width - 40)).'COUNT'.PHP_EOL; } } echo "\033[0m".str_repeat('-', $width).PHP_EOL; $fixableSources = 0; if ($showSources === true) { $maxSniffWidth = ($width - 7); } else { $maxSniffWidth = ($width - 37); } if ($totalFixable > 0) { $maxSniffWidth -= 4; } foreach ($sources as $source => $sourceData) { if ($totalFixable > 0) { echo '['; if ($sourceData['fixable'] === true) { echo 'x'; $fixableSources++; } else { echo ' '; } echo '] '; } if ($showSources === true) { if (strlen($source) > $maxSniffWidth) { $source = substr($source, 0, $maxSniffWidth); } echo $source; if ($totalFixable > 0) { echo str_repeat(' ', ($width - 9 - strlen($source))); } else { echo str_repeat(' ', ($width - 5 - strlen($source))); } } else { $parts = $sourceData['parts']; if (strlen($parts[0]) > 8) { $parts[0] = substr($parts[0], 0, ((strlen($parts[0]) - 8) * -1)); } echo $parts[0].str_repeat(' ', (10 - strlen($parts[0]))); $category = $parts[1]; if (strlen($category) > 18) { $category = substr($category, 0, ((strlen($category) - 18) * -1)); } echo $category.str_repeat(' ', (20 - strlen($category))); $sniff = $parts[2]; if (strlen($sniff) > $maxSniffWidth) { $sniff = substr($sniff, 0, $maxSniffWidth); } if ($totalFixable > 0) { echo $sniff.str_repeat(' ', ($width - 39 - strlen($sniff))); } else { echo $sniff.str_repeat(' ', ($width - 35 - strlen($sniff))); } }//end if echo $sourceData['count'].PHP_EOL; }//end foreach echo str_repeat('-', $width).PHP_EOL; echo "\033[1m".'A TOTAL OF '.($totalErrors + $totalWarnings).' SNIFF VIOLATION'; if (($totalErrors + $totalWarnings) > 1) { echo 'S'; } echo ' WERE FOUND IN '.count($sources).' SOURCE'; if (count($sources) !== 1) { echo 'S'; } echo "\033[0m"; if ($totalFixable > 0) { echo PHP_EOL.str_repeat('-', $width).PHP_EOL; echo "\033[1mPHPCBF CAN FIX THE $fixableSources MARKED SOURCES AUTOMATICALLY ($totalFixable VIOLATIONS IN TOTAL)\033[0m"; } echo PHP_EOL.str_repeat('-', $width).PHP_EOL.PHP_EOL; if ($toScreen === true && $interactive === false) { Timing::printRunTime(); } }//end generate() /** * Converts a camel caps name into a readable string. * * @param string $name The camel caps name to convert. * * @return string */ public function makeFriendlyName($name) { if (trim($name) === '') { return ''; } $friendlyName = ''; $length = strlen($name); $lastWasUpper = false; $lastWasNumeric = false; for ($i = 0; $i < $length; $i++) { if (is_numeric($name[$i]) === true) { if ($lastWasNumeric === false) { $friendlyName .= ' '; } $lastWasUpper = false; $lastWasNumeric = true; } else { $lastWasNumeric = false; $char = strtolower($name[$i]); if ($char === $name[$i]) { // Lowercase. $lastWasUpper = false; } else { // Uppercase. if ($lastWasUpper === false) { $friendlyName .= ' '; if ($i < ($length - 1)) { $next = $name[($i + 1)]; if (strtolower($next) === $next) { // Next char is lowercase so it is a word boundary. $name[$i] = strtolower($name[$i]); } } } $lastWasUpper = true; } }//end if $friendlyName .= $name[$i]; }//end for $friendlyName = trim($friendlyName); $friendlyName[0] = strtoupper($friendlyName[0]); return $friendlyName; }//end makeFriendlyName() }//end class PHP_CodeSniffer-3.5.4/src/Reports/Summary.php0000644000076500000240000001346313614652361020716 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Reports; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Util; class Summary implements Report { /** * Generate a partial report for a single processed file. * * Function should return TRUE if it printed or stored data about the file * and FALSE if it ignored the file. Returning TRUE indicates that the file and * its data should be counted in the grand totals. * * @param array $report Prepared report data. * @param \PHP_CodeSniffer\File $phpcsFile The file being reported on. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * * @return bool */ public function generateFileReport($report, File $phpcsFile, $showSources=false, $width=80) { if (PHP_CODESNIFFER_VERBOSITY === 0 && $report['errors'] === 0 && $report['warnings'] === 0 ) { // Nothing to print. return false; } echo $report['filename'].'>>'.$report['errors'].'>>'.$report['warnings'].PHP_EOL; return true; }//end generateFileReport() /** * Generates a summary of errors and warnings for each file processed. * * @param string $cachedData Any partial report data that was returned from * generateFileReport during the run. * @param int $totalFiles Total number of files processed during the run. * @param int $totalErrors Total number of errors found during the run. * @param int $totalWarnings Total number of warnings found during the run. * @param int $totalFixable Total number of problems that can be fixed. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * @param bool $interactive Are we running in interactive mode? * @param bool $toScreen Is the report being printed to screen? * * @return void */ public function generate( $cachedData, $totalFiles, $totalErrors, $totalWarnings, $totalFixable, $showSources=false, $width=80, $interactive=false, $toScreen=true ) { $lines = explode(PHP_EOL, $cachedData); array_pop($lines); if (empty($lines) === true) { return; } $reportFiles = []; $maxLength = 0; foreach ($lines as $line) { $parts = explode('>>', $line); $fileLen = strlen($parts[0]); $reportFiles[$parts[0]] = [ 'errors' => $parts[1], 'warnings' => $parts[2], 'strlen' => $fileLen, ]; $maxLength = max($maxLength, $fileLen); } uksort( $reportFiles, function ($keyA, $keyB) { $pathPartsA = explode(DIRECTORY_SEPARATOR, $keyA); $pathPartsB = explode(DIRECTORY_SEPARATOR, $keyB); do { $partA = array_shift($pathPartsA); $partB = array_shift($pathPartsB); } while ($partA === $partB && empty($pathPartsA) === false && empty($pathPartsB) === false); if (empty($pathPartsA) === false && empty($pathPartsB) === true) { return 1; } else if (empty($pathPartsA) === true && empty($pathPartsB) === false) { return -1; } else { return strcasecmp($partA, $partB); } } ); $width = min($width, ($maxLength + 21)); $width = max($width, 70); echo PHP_EOL."\033[1m".'PHP CODE SNIFFER REPORT SUMMARY'."\033[0m".PHP_EOL; echo str_repeat('-', $width).PHP_EOL; echo "\033[1m".'FILE'.str_repeat(' ', ($width - 20)).'ERRORS WARNINGS'."\033[0m".PHP_EOL; echo str_repeat('-', $width).PHP_EOL; foreach ($reportFiles as $file => $data) { $padding = ($width - 18 - $data['strlen']); if ($padding < 0) { $file = '...'.substr($file, (($padding * -1) + 3)); $padding = 0; } echo $file.str_repeat(' ', $padding).' '; if ($data['errors'] !== 0) { echo "\033[31m".$data['errors']."\033[0m"; echo str_repeat(' ', (8 - strlen((string) $data['errors']))); } else { echo '0 '; } if ($data['warnings'] !== 0) { echo "\033[33m".$data['warnings']."\033[0m"; } else { echo '0'; } echo PHP_EOL; }//end foreach echo str_repeat('-', $width).PHP_EOL; echo "\033[1mA TOTAL OF $totalErrors ERROR"; if ($totalErrors !== 1) { echo 'S'; } echo ' AND '.$totalWarnings.' WARNING'; if ($totalWarnings !== 1) { echo 'S'; } echo ' WERE FOUND IN '.$totalFiles.' FILE'; if ($totalFiles !== 1) { echo 'S'; } echo "\033[0m"; if ($totalFixable > 0) { echo PHP_EOL.str_repeat('-', $width).PHP_EOL; echo "\033[1mPHPCBF CAN FIX $totalFixable OF THESE SNIFF VIOLATIONS AUTOMATICALLY\033[0m"; } echo PHP_EOL.str_repeat('-', $width).PHP_EOL.PHP_EOL; if ($toScreen === true && $interactive === false) { Util\Timing::printRunTime(); } }//end generate() }//end class PHP_CodeSniffer-3.5.4/src/Reports/Svnblame.php0000644000076500000240000000323413614652361021023 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Reports; use PHP_CodeSniffer\Exceptions\DeepExitException; class Svnblame extends VersionControl { /** * The name of the report we want in the output * * @var string */ protected $reportName = 'SVN'; /** * Extract the author from a blame line. * * @param string $line Line to parse. * * @return mixed string or false if impossible to recover. */ protected function getAuthor($line) { $blameParts = []; preg_match('|\s*([^\s]+)\s+([^\s]+)|', $line, $blameParts); if (isset($blameParts[2]) === false) { return false; } return $blameParts[2]; }//end getAuthor() /** * Gets the blame output. * * @param string $filename File to blame. * * @return array * @throws \PHP_CodeSniffer\Exceptions\DeepExitException */ protected function getBlameContent($filename) { $command = 'svn blame "'.$filename.'" 2>&1'; $handle = popen($command, 'r'); if ($handle === false) { $error = 'ERROR: Could not execute "'.$command.'"'.PHP_EOL.PHP_EOL; throw new DeepExitException($error, 3); } $rawContent = stream_get_contents($handle); fclose($handle); $blames = explode("\n", $rawContent); return $blames; }//end getBlameContent() }//end class PHP_CodeSniffer-3.5.4/src/Reports/VersionControl.php0000644000076500000240000003074213614652361022246 0ustar gsherwoodstaff * @author Greg Sherwood * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Reports; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Util\Timing; abstract class VersionControl implements Report { /** * The name of the report we want in the output. * * @var string */ protected $reportName = 'VERSION CONTROL'; /** * Generate a partial report for a single processed file. * * Function should return TRUE if it printed or stored data about the file * and FALSE if it ignored the file. Returning TRUE indicates that the file and * its data should be counted in the grand totals. * * @param array $report Prepared report data. * @param \PHP_CodeSniffer\File $phpcsFile The file being reported on. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * * @return bool */ public function generateFileReport($report, File $phpcsFile, $showSources=false, $width=80) { $blames = $this->getBlameContent($report['filename']); $authorCache = []; $praiseCache = []; $sourceCache = []; foreach ($report['messages'] as $line => $lineErrors) { $author = 'Unknown'; if (isset($blames[($line - 1)]) === true) { $blameAuthor = $this->getAuthor($blames[($line - 1)]); if ($blameAuthor !== false) { $author = $blameAuthor; } } if (isset($authorCache[$author]) === false) { $authorCache[$author] = 0; $praiseCache[$author] = [ 'good' => 0, 'bad' => 0, ]; } $praiseCache[$author]['bad']++; foreach ($lineErrors as $column => $colErrors) { foreach ($colErrors as $error) { $authorCache[$author]++; if ($showSources === true) { $source = $error['source']; if (isset($sourceCache[$author][$source]) === false) { $sourceCache[$author][$source] = [ 'count' => 1, 'fixable' => $error['fixable'], ]; } else { $sourceCache[$author][$source]['count']++; } } } } unset($blames[($line - 1)]); }//end foreach // Now go through and give the authors some credit for // all the lines that do not have errors. foreach ($blames as $line) { $author = $this->getAuthor($line); if ($author === false) { $author = 'Unknown'; } if (isset($authorCache[$author]) === false) { // This author doesn't have any errors. if (PHP_CODESNIFFER_VERBOSITY === 0) { continue; } $authorCache[$author] = 0; $praiseCache[$author] = [ 'good' => 0, 'bad' => 0, ]; } $praiseCache[$author]['good']++; }//end foreach foreach ($authorCache as $author => $errors) { echo "AUTHOR>>$author>>$errors".PHP_EOL; } foreach ($praiseCache as $author => $praise) { echo "PRAISE>>$author>>".$praise['good'].'>>'.$praise['bad'].PHP_EOL; } foreach ($sourceCache as $author => $sources) { foreach ($sources as $source => $sourceData) { $count = $sourceData['count']; $fixable = (int) $sourceData['fixable']; echo "SOURCE>>$author>>$source>>$count>>$fixable".PHP_EOL; } } return true; }//end generateFileReport() /** * Prints the author of all errors and warnings, as given by "version control blame". * * @param string $cachedData Any partial report data that was returned from * generateFileReport during the run. * @param int $totalFiles Total number of files processed during the run. * @param int $totalErrors Total number of errors found during the run. * @param int $totalWarnings Total number of warnings found during the run. * @param int $totalFixable Total number of problems that can be fixed. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * @param bool $interactive Are we running in interactive mode? * @param bool $toScreen Is the report being printed to screen? * * @return void */ public function generate( $cachedData, $totalFiles, $totalErrors, $totalWarnings, $totalFixable, $showSources=false, $width=80, $interactive=false, $toScreen=true ) { $errorsShown = ($totalErrors + $totalWarnings); if ($errorsShown === 0) { // Nothing to show. return; } $lines = explode(PHP_EOL, $cachedData); array_pop($lines); if (empty($lines) === true) { return; } $authorCache = []; $praiseCache = []; $sourceCache = []; foreach ($lines as $line) { $parts = explode('>>', $line); switch ($parts[0]) { case 'AUTHOR': if (isset($authorCache[$parts[1]]) === false) { $authorCache[$parts[1]] = $parts[2]; } else { $authorCache[$parts[1]] += $parts[2]; } break; case 'PRAISE': if (isset($praiseCache[$parts[1]]) === false) { $praiseCache[$parts[1]] = [ 'good' => $parts[2], 'bad' => $parts[3], ]; } else { $praiseCache[$parts[1]]['good'] += $parts[2]; $praiseCache[$parts[1]]['bad'] += $parts[3]; } break; case 'SOURCE': if (isset($praiseCache[$parts[1]]) === false) { $praiseCache[$parts[1]] = []; } if (isset($sourceCache[$parts[1]][$parts[2]]) === false) { $sourceCache[$parts[1]][$parts[2]] = [ 'count' => $parts[3], 'fixable' => (bool) $parts[4], ]; } else { $sourceCache[$parts[1]][$parts[2]]['count'] += $parts[3]; } break; default: break; }//end switch }//end foreach // Make sure the report width isn't too big. $maxLength = 0; foreach ($authorCache as $author => $count) { $maxLength = max($maxLength, strlen($author)); if ($showSources === true && isset($sourceCache[$author]) === true) { foreach ($sourceCache[$author] as $source => $sourceData) { if ($source === 'count') { continue; } $maxLength = max($maxLength, (strlen($source) + 9)); } } } $width = min($width, ($maxLength + 30)); $width = max($width, 70); arsort($authorCache); echo PHP_EOL."\033[1m".'PHP CODE SNIFFER '.$this->reportName.' BLAME SUMMARY'."\033[0m".PHP_EOL; echo str_repeat('-', $width).PHP_EOL."\033[1m"; if ($showSources === true) { echo 'AUTHOR SOURCE'.str_repeat(' ', ($width - 43)).'(Author %) (Overall %) COUNT'.PHP_EOL; echo str_repeat('-', $width).PHP_EOL; } else { echo 'AUTHOR'.str_repeat(' ', ($width - 34)).'(Author %) (Overall %) COUNT'.PHP_EOL; echo str_repeat('-', $width).PHP_EOL; } echo "\033[0m"; if ($showSources === true) { $maxSniffWidth = ($width - 15); if ($totalFixable > 0) { $maxSniffWidth -= 4; } } $fixableSources = 0; foreach ($authorCache as $author => $count) { if ($praiseCache[$author]['good'] === 0) { $percent = 0; } else { $total = ($praiseCache[$author]['bad'] + $praiseCache[$author]['good']); $percent = round(($praiseCache[$author]['bad'] / $total * 100), 2); } $overallPercent = '('.round((($count / $errorsShown) * 100), 2).')'; $authorPercent = '('.$percent.')'; $line = str_repeat(' ', (6 - strlen($count))).$count; $line = str_repeat(' ', (12 - strlen($overallPercent))).$overallPercent.$line; $line = str_repeat(' ', (11 - strlen($authorPercent))).$authorPercent.$line; $line = $author.str_repeat(' ', ($width - strlen($author) - strlen($line))).$line; if ($showSources === true) { $line = "\033[1m$line\033[0m"; } echo $line.PHP_EOL; if ($showSources === true && isset($sourceCache[$author]) === true) { $errors = $sourceCache[$author]; asort($errors); $errors = array_reverse($errors); foreach ($errors as $source => $sourceData) { if ($source === 'count') { continue; } $count = $sourceData['count']; $srcLength = strlen($source); if ($srcLength > $maxSniffWidth) { $source = substr($source, 0, $maxSniffWidth); } $line = str_repeat(' ', (5 - strlen($count))).$count; echo ' '; if ($totalFixable > 0) { echo '['; if ($sourceData['fixable'] === true) { echo 'x'; $fixableSources++; } else { echo ' '; } echo '] '; } echo $source; if ($totalFixable > 0) { echo str_repeat(' ', ($width - 18 - strlen($source))); } else { echo str_repeat(' ', ($width - 14 - strlen($source))); } echo $line.PHP_EOL; }//end foreach }//end if }//end foreach echo str_repeat('-', $width).PHP_EOL; echo "\033[1m".'A TOTAL OF '.$errorsShown.' SNIFF VIOLATION'; if ($errorsShown !== 1) { echo 'S'; } echo ' WERE COMMITTED BY '.count($authorCache).' AUTHOR'; if (count($authorCache) !== 1) { echo 'S'; } echo "\033[0m"; if ($totalFixable > 0) { if ($showSources === true) { echo PHP_EOL.str_repeat('-', $width).PHP_EOL; echo "\033[1mPHPCBF CAN FIX THE $fixableSources MARKED SOURCES AUTOMATICALLY ($totalFixable VIOLATIONS IN TOTAL)\033[0m"; } else { echo PHP_EOL.str_repeat('-', $width).PHP_EOL; echo "\033[1mPHPCBF CAN FIX $totalFixable OF THESE SNIFF VIOLATIONS AUTOMATICALLY\033[0m"; } } echo PHP_EOL.str_repeat('-', $width).PHP_EOL.PHP_EOL; if ($toScreen === true && $interactive === false) { Timing::printRunTime(); } }//end generate() /** * Extract the author from a blame line. * * @param string $line Line to parse. * * @return mixed string or false if impossible to recover. */ abstract protected function getAuthor($line); /** * Gets the blame output. * * @param string $filename File to blame. * * @return array */ abstract protected function getBlameContent($filename); }//end class PHP_CodeSniffer-3.5.4/src/Reports/Xml.php0000644000076500000240000001100013614652361020002 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Reports; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Files\File; class Xml implements Report { /** * Generate a partial report for a single processed file. * * Function should return TRUE if it printed or stored data about the file * and FALSE if it ignored the file. Returning TRUE indicates that the file and * its data should be counted in the grand totals. * * @param array $report Prepared report data. * @param \PHP_CodeSniffer\File $phpcsFile The file being reported on. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * * @return bool */ public function generateFileReport($report, File $phpcsFile, $showSources=false, $width=80) { $out = new \XMLWriter; $out->openMemory(); $out->setIndent(true); $out->setIndentString(' '); $out->startDocument('1.0', 'UTF-8'); if ($report['errors'] === 0 && $report['warnings'] === 0) { // Nothing to print. return false; } $out->startElement('file'); $out->writeAttribute('name', $report['filename']); $out->writeAttribute('errors', $report['errors']); $out->writeAttribute('warnings', $report['warnings']); $out->writeAttribute('fixable', $report['fixable']); foreach ($report['messages'] as $line => $lineErrors) { foreach ($lineErrors as $column => $colErrors) { foreach ($colErrors as $error) { $error['type'] = strtolower($error['type']); if ($phpcsFile->config->encoding !== 'utf-8') { $error['message'] = iconv($phpcsFile->config->encoding, 'utf-8', $error['message']); } $out->startElement($error['type']); $out->writeAttribute('line', $line); $out->writeAttribute('column', $column); $out->writeAttribute('source', $error['source']); $out->writeAttribute('severity', $error['severity']); $out->writeAttribute('fixable', (int) $error['fixable']); $out->text($error['message']); $out->endElement(); } } }//end foreach $out->endElement(); // Remove the start of the document because we will // add that manually later. We only have it in here to // properly set the encoding. $content = $out->flush(); if (strpos($content, PHP_EOL) !== false) { $content = substr($content, (strpos($content, PHP_EOL) + strlen(PHP_EOL))); } else if (strpos($content, "\n") !== false) { $content = substr($content, (strpos($content, "\n") + 1)); } echo $content; return true; }//end generateFileReport() /** * Prints all violations for processed files, in a proprietary XML format. * * @param string $cachedData Any partial report data that was returned from * generateFileReport during the run. * @param int $totalFiles Total number of files processed during the run. * @param int $totalErrors Total number of errors found during the run. * @param int $totalWarnings Total number of warnings found during the run. * @param int $totalFixable Total number of problems that can be fixed. * @param bool $showSources Show sources? * @param int $width Maximum allowed line width. * @param bool $interactive Are we running in interactive mode? * @param bool $toScreen Is the report being printed to screen? * * @return void */ public function generate( $cachedData, $totalFiles, $totalErrors, $totalWarnings, $totalFixable, $showSources=false, $width=80, $interactive=false, $toScreen=true ) { echo ''.PHP_EOL; echo ''.PHP_EOL; echo $cachedData; echo ''.PHP_EOL; }//end generate() }//end class PHP_CodeSniffer-3.5.4/src/Sniffs/AbstractArraySniff.php0000644000076500000240000001420413614652361022575 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Sniffs; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Util\Tokens; abstract class AbstractArraySniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ final public function register() { return [ T_ARRAY, T_OPEN_SHORT_ARRAY, ]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being checked. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if ($tokens[$stackPtr]['code'] === T_ARRAY) { $phpcsFile->recordMetric($stackPtr, 'Short array syntax used', 'no'); $arrayStart = $tokens[$stackPtr]['parenthesis_opener']; if (isset($tokens[$arrayStart]['parenthesis_closer']) === false) { // Incomplete array. return; } $arrayEnd = $tokens[$arrayStart]['parenthesis_closer']; } else { $phpcsFile->recordMetric($stackPtr, 'Short array syntax used', 'yes'); $arrayStart = $stackPtr; $arrayEnd = $tokens[$stackPtr]['bracket_closer']; } $lastContent = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($arrayEnd - 1), null, true); if ($tokens[$lastContent]['code'] === T_COMMA) { // Last array item ends with a comma. $phpcsFile->recordMetric($stackPtr, 'Array end comma', 'yes'); } else { $phpcsFile->recordMetric($stackPtr, 'Array end comma', 'no'); } $indices = []; $current = $arrayStart; while (($next = $phpcsFile->findNext(Tokens::$emptyTokens, ($current + 1), $arrayEnd, true)) !== false) { $end = $this->getNext($phpcsFile, $next, $arrayEnd); if ($tokens[$end]['code'] === T_DOUBLE_ARROW) { $indexEnd = $phpcsFile->findPrevious(T_WHITESPACE, ($end - 1), null, true); $valueStart = $phpcsFile->findNext(Tokens::$emptyTokens, ($end + 1), null, true); $indices[] = [ 'index_start' => $next, 'index_end' => $indexEnd, 'arrow' => $end, 'value_start' => $valueStart, ]; } else { $valueStart = $next; $indices[] = ['value_start' => $valueStart]; } $current = $this->getNext($phpcsFile, $valueStart, $arrayEnd); } if ($tokens[$arrayStart]['line'] === $tokens[$arrayEnd]['line']) { $this->processSingleLineArray($phpcsFile, $stackPtr, $arrayStart, $arrayEnd, $indices); } else { $this->processMultiLineArray($phpcsFile, $stackPtr, $arrayStart, $arrayEnd, $indices); } }//end process() /** * Find next separator in array - either: comma or double arrow. * * @param File $phpcsFile The current file being checked. * @param int $ptr The position of current token. * @param int $arrayEnd The token that ends the array definition. * * @return int */ private function getNext(File $phpcsFile, $ptr, $arrayEnd) { $tokens = $phpcsFile->getTokens(); while ($ptr < $arrayEnd) { if (isset($tokens[$ptr]['scope_closer']) === true) { $ptr = $tokens[$ptr]['scope_closer']; } else if (isset($tokens[$ptr]['parenthesis_closer']) === true) { $ptr = $tokens[$ptr]['parenthesis_closer']; } else if (isset($tokens[$ptr]['bracket_closer']) === true) { $ptr = $tokens[$ptr]['bracket_closer']; } if ($tokens[$ptr]['code'] === T_COMMA || $tokens[$ptr]['code'] === T_DOUBLE_ARROW ) { return $ptr; } ++$ptr; } return $ptr; }//end getNext() /** * Processes a single-line array definition. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being checked. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param int $arrayStart The token that starts the array definition. * @param int $arrayEnd The token that ends the array definition. * @param array $indices An array of token positions for the array keys, * double arrows, and values. * * @return void */ abstract protected function processSingleLineArray($phpcsFile, $stackPtr, $arrayStart, $arrayEnd, $indices); /** * Processes a multi-line array definition. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being checked. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param int $arrayStart The token that starts the array definition. * @param int $arrayEnd The token that ends the array definition. * @param array $indices An array of token positions for the array keys, * double arrows, and values. * * @return void */ abstract protected function processMultiLineArray($phpcsFile, $stackPtr, $arrayStart, $arrayEnd, $indices); }//end class PHP_CodeSniffer-3.5.4/src/Sniffs/AbstractPatternSniff.php0000644000076500000240000010440013614652361023132 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Sniffs; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Util\Tokens; use PHP_CodeSniffer\Tokenizers\PHP; use PHP_CodeSniffer\Exceptions\RuntimeException; abstract class AbstractPatternSniff implements Sniff { /** * If true, comments will be ignored if they are found in the code. * * @var boolean */ public $ignoreComments = false; /** * The current file being checked. * * @var string */ protected $currFile = ''; /** * The parsed patterns array. * * @var array */ private $parsedPatterns = []; /** * Tokens that this sniff wishes to process outside of the patterns. * * @var int[] * @see registerSupplementary() * @see processSupplementary() */ private $supplementaryTokens = []; /** * Positions in the stack where errors have occurred. * * @var array */ private $errorPos = []; /** * Constructs a AbstractPatternSniff. * * @param boolean $ignoreComments If true, comments will be ignored. */ public function __construct($ignoreComments=null) { // This is here for backwards compatibility. if ($ignoreComments !== null) { $this->ignoreComments = $ignoreComments; } $this->supplementaryTokens = $this->registerSupplementary(); }//end __construct() /** * Registers the tokens to listen to. * * Classes extending AbstractPatternTest should implement the * getPatterns() method to register the patterns they wish to test. * * @return int[] * @see process() */ final public function register() { $listenTypes = []; $patterns = $this->getPatterns(); foreach ($patterns as $pattern) { $parsedPattern = $this->parse($pattern); // Find a token position in the pattern that we can use // for a listener token. $pos = $this->getListenerTokenPos($parsedPattern); $tokenType = $parsedPattern[$pos]['token']; $listenTypes[] = $tokenType; $patternArray = [ 'listen_pos' => $pos, 'pattern' => $parsedPattern, 'pattern_code' => $pattern, ]; if (isset($this->parsedPatterns[$tokenType]) === false) { $this->parsedPatterns[$tokenType] = []; } $this->parsedPatterns[$tokenType][] = $patternArray; }//end foreach return array_unique(array_merge($listenTypes, $this->supplementaryTokens)); }//end register() /** * Returns the token types that the specified pattern is checking for. * * Returned array is in the format: * * array( * T_WHITESPACE => 0, // 0 is the position where the T_WHITESPACE token * // should occur in the pattern. * ); * * * @param array $pattern The parsed pattern to find the acquire the token * types from. * * @return array */ private function getPatternTokenTypes($pattern) { $tokenTypes = []; foreach ($pattern as $pos => $patternInfo) { if ($patternInfo['type'] === 'token') { if (isset($tokenTypes[$patternInfo['token']]) === false) { $tokenTypes[$patternInfo['token']] = $pos; } } } return $tokenTypes; }//end getPatternTokenTypes() /** * Returns the position in the pattern that this test should register as * a listener for the pattern. * * @param array $pattern The pattern to acquire the listener for. * * @return int The position in the pattern that this test should register * as the listener. * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If we could not determine a token to listen for. */ private function getListenerTokenPos($pattern) { $tokenTypes = $this->getPatternTokenTypes($pattern); $tokenCodes = array_keys($tokenTypes); $token = Tokens::getHighestWeightedToken($tokenCodes); // If we could not get a token. if ($token === false) { $error = 'Could not determine a token to listen for'; throw new RuntimeException($error); } return $tokenTypes[$token]; }//end getListenerTokenPos() /** * Processes the test. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where the * token occurred. * @param int $stackPtr The position in the tokens stack * where the listening token type * was found. * * @return void * @see register() */ final public function process(File $phpcsFile, $stackPtr) { $file = $phpcsFile->getFilename(); if ($this->currFile !== $file) { // We have changed files, so clean up. $this->errorPos = []; $this->currFile = $file; } $tokens = $phpcsFile->getTokens(); if (in_array($tokens[$stackPtr]['code'], $this->supplementaryTokens, true) === true) { $this->processSupplementary($phpcsFile, $stackPtr); } $type = $tokens[$stackPtr]['code']; // If the type is not set, then it must have been a token registered // with registerSupplementary(). if (isset($this->parsedPatterns[$type]) === false) { return; } $allErrors = []; // Loop over each pattern that is listening to the current token type // that we are processing. foreach ($this->parsedPatterns[$type] as $patternInfo) { // If processPattern returns false, then the pattern that we are // checking the code with must not be designed to check that code. $errors = $this->processPattern($patternInfo, $phpcsFile, $stackPtr); if ($errors === false) { // The pattern didn't match. continue; } else if (empty($errors) === true) { // The pattern matched, but there were no errors. break; } foreach ($errors as $stackPtr => $error) { if (isset($this->errorPos[$stackPtr]) === false) { $this->errorPos[$stackPtr] = true; $allErrors[$stackPtr] = $error; } } } foreach ($allErrors as $stackPtr => $error) { $phpcsFile->addError($error, $stackPtr, 'Found'); } }//end process() /** * Processes the pattern and verifies the code at $stackPtr. * * @param array $patternInfo Information about the pattern used * for checking, which includes are * parsed token representation of the * pattern. * @param \PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where the * token occurred. * @param int $stackPtr The position in the tokens stack where * the listening token type was found. * * @return array */ protected function processPattern($patternInfo, File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $pattern = $patternInfo['pattern']; $patternCode = $patternInfo['pattern_code']; $errors = []; $found = ''; $ignoreTokens = [T_WHITESPACE => T_WHITESPACE]; if ($this->ignoreComments === true) { $ignoreTokens += Tokens::$commentTokens; } $origStackPtr = $stackPtr; $hasError = false; if ($patternInfo['listen_pos'] > 0) { $stackPtr--; for ($i = ($patternInfo['listen_pos'] - 1); $i >= 0; $i--) { if ($pattern[$i]['type'] === 'token') { if ($pattern[$i]['token'] === T_WHITESPACE) { if ($tokens[$stackPtr]['code'] === T_WHITESPACE) { $found = $tokens[$stackPtr]['content'].$found; } // Only check the size of the whitespace if this is not // the first token. We don't care about the size of // leading whitespace, just that there is some. if ($i !== 0) { if ($tokens[$stackPtr]['content'] !== $pattern[$i]['value']) { $hasError = true; } } } else { // Check to see if this important token is the same as the // previous important token in the pattern. If it is not, // then the pattern cannot be for this piece of code. $prev = $phpcsFile->findPrevious( $ignoreTokens, $stackPtr, null, true ); if ($prev === false || $tokens[$prev]['code'] !== $pattern[$i]['token'] ) { return false; } // If we skipped past some whitespace tokens, then add them // to the found string. $tokenContent = $phpcsFile->getTokensAsString( ($prev + 1), ($stackPtr - $prev - 1) ); $found = $tokens[$prev]['content'].$tokenContent.$found; if (isset($pattern[($i - 1)]) === true && $pattern[($i - 1)]['type'] === 'skip' ) { $stackPtr = $prev; } else { $stackPtr = ($prev - 1); } }//end if } else if ($pattern[$i]['type'] === 'skip') { // Skip to next piece of relevant code. if ($pattern[$i]['to'] === 'parenthesis_closer') { $to = 'parenthesis_opener'; } else { $to = 'scope_opener'; } // Find the previous opener. $next = $phpcsFile->findPrevious( $ignoreTokens, $stackPtr, null, true ); if ($next === false || isset($tokens[$next][$to]) === false) { // If there was not opener, then we must be // using the wrong pattern. return false; } if ($to === 'parenthesis_opener') { $found = '{'.$found; } else { $found = '('.$found; } $found = '...'.$found; // Skip to the opening token. $stackPtr = ($tokens[$next][$to] - 1); } else if ($pattern[$i]['type'] === 'string') { $found = 'abc'; } else if ($pattern[$i]['type'] === 'newline') { if ($this->ignoreComments === true && isset(Tokens::$commentTokens[$tokens[$stackPtr]['code']]) === true ) { $startComment = $phpcsFile->findPrevious( Tokens::$commentTokens, ($stackPtr - 1), null, true ); if ($tokens[$startComment]['line'] !== $tokens[($startComment + 1)]['line']) { $startComment++; } $tokenContent = $phpcsFile->getTokensAsString( $startComment, ($stackPtr - $startComment + 1) ); $found = $tokenContent.$found; $stackPtr = ($startComment - 1); } if ($tokens[$stackPtr]['code'] === T_WHITESPACE) { if ($tokens[$stackPtr]['content'] !== $phpcsFile->eolChar) { $found = $tokens[$stackPtr]['content'].$found; // This may just be an indent that comes after a newline // so check the token before to make sure. If it is a newline, we // can ignore the error here. if (($tokens[($stackPtr - 1)]['content'] !== $phpcsFile->eolChar) && ($this->ignoreComments === true && isset(Tokens::$commentTokens[$tokens[($stackPtr - 1)]['code']]) === false) ) { $hasError = true; } else { $stackPtr--; } } else { $found = 'EOL'.$found; } } else { $found = $tokens[$stackPtr]['content'].$found; $hasError = true; }//end if if ($hasError === false && $pattern[($i - 1)]['type'] !== 'newline') { // Make sure they only have 1 newline. $prev = $phpcsFile->findPrevious($ignoreTokens, ($stackPtr - 1), null, true); if ($prev !== false && $tokens[$prev]['line'] !== $tokens[$stackPtr]['line']) { $hasError = true; } } }//end if }//end for }//end if $stackPtr = $origStackPtr; $lastAddedStackPtr = null; $patternLen = count($pattern); for ($i = $patternInfo['listen_pos']; $i < $patternLen; $i++) { if (isset($tokens[$stackPtr]) === false) { break; } if ($pattern[$i]['type'] === 'token') { if ($pattern[$i]['token'] === T_WHITESPACE) { if ($this->ignoreComments === true) { // If we are ignoring comments, check to see if this current // token is a comment. If so skip it. if (isset(Tokens::$commentTokens[$tokens[$stackPtr]['code']]) === true) { continue; } // If the next token is a comment, the we need to skip the // current token as we should allow a space before a // comment for readability. if (isset($tokens[($stackPtr + 1)]) === true && isset(Tokens::$commentTokens[$tokens[($stackPtr + 1)]['code']]) === true ) { continue; } } $tokenContent = ''; if ($tokens[$stackPtr]['code'] === T_WHITESPACE) { if (isset($pattern[($i + 1)]) === false) { // This is the last token in the pattern, so just compare // the next token of content. $tokenContent = $tokens[$stackPtr]['content']; } else { // Get all the whitespace to the next token. $next = $phpcsFile->findNext( Tokens::$emptyTokens, $stackPtr, null, true ); $tokenContent = $phpcsFile->getTokensAsString( $stackPtr, ($next - $stackPtr) ); $lastAddedStackPtr = $stackPtr; $stackPtr = $next; }//end if if ($stackPtr !== $lastAddedStackPtr) { $found .= $tokenContent; } } else { if ($stackPtr !== $lastAddedStackPtr) { $found .= $tokens[$stackPtr]['content']; $lastAddedStackPtr = $stackPtr; } }//end if if (isset($pattern[($i + 1)]) === true && $pattern[($i + 1)]['type'] === 'skip' ) { // The next token is a skip token, so we just need to make // sure the whitespace we found has *at least* the // whitespace required. if (strpos($tokenContent, $pattern[$i]['value']) !== 0) { $hasError = true; } } else { if ($tokenContent !== $pattern[$i]['value']) { $hasError = true; } } } else { // Check to see if this important token is the same as the // next important token in the pattern. If it is not, then // the pattern cannot be for this piece of code. $next = $phpcsFile->findNext( $ignoreTokens, $stackPtr, null, true ); if ($next === false || $tokens[$next]['code'] !== $pattern[$i]['token'] ) { // The next important token did not match the pattern. return false; } if ($lastAddedStackPtr !== null) { if (($tokens[$next]['code'] === T_OPEN_CURLY_BRACKET || $tokens[$next]['code'] === T_CLOSE_CURLY_BRACKET) && isset($tokens[$next]['scope_condition']) === true && $tokens[$next]['scope_condition'] > $lastAddedStackPtr ) { // This is a brace, but the owner of it is after the current // token, which means it does not belong to any token in // our pattern. This means the pattern is not for us. return false; } if (($tokens[$next]['code'] === T_OPEN_PARENTHESIS || $tokens[$next]['code'] === T_CLOSE_PARENTHESIS) && isset($tokens[$next]['parenthesis_owner']) === true && $tokens[$next]['parenthesis_owner'] > $lastAddedStackPtr ) { // This is a bracket, but the owner of it is after the current // token, which means it does not belong to any token in // our pattern. This means the pattern is not for us. return false; } }//end if // If we skipped past some whitespace tokens, then add them // to the found string. if (($next - $stackPtr) > 0) { $hasComment = false; for ($j = $stackPtr; $j < $next; $j++) { $found .= $tokens[$j]['content']; if (isset(Tokens::$commentTokens[$tokens[$j]['code']]) === true) { $hasComment = true; } } // If we are not ignoring comments, this additional // whitespace or comment is not allowed. If we are // ignoring comments, there needs to be at least one // comment for this to be allowed. if ($this->ignoreComments === false || ($this->ignoreComments === true && $hasComment === false) ) { $hasError = true; } // Even when ignoring comments, we are not allowed to include // newlines without the pattern specifying them, so // everything should be on the same line. if ($tokens[$next]['line'] !== $tokens[$stackPtr]['line']) { $hasError = true; } }//end if if ($next !== $lastAddedStackPtr) { $found .= $tokens[$next]['content']; $lastAddedStackPtr = $next; } if (isset($pattern[($i + 1)]) === true && $pattern[($i + 1)]['type'] === 'skip' ) { $stackPtr = $next; } else { $stackPtr = ($next + 1); } }//end if } else if ($pattern[$i]['type'] === 'skip') { if ($pattern[$i]['to'] === 'unknown') { $next = $phpcsFile->findNext( $pattern[($i + 1)]['token'], $stackPtr ); if ($next === false) { // Couldn't find the next token, so we must // be using the wrong pattern. return false; } $found .= '...'; $stackPtr = $next; } else { // Find the previous opener. $next = $phpcsFile->findPrevious( Tokens::$blockOpeners, $stackPtr ); if ($next === false || isset($tokens[$next][$pattern[$i]['to']]) === false ) { // If there was not opener, then we must // be using the wrong pattern. return false; } $found .= '...'; if ($pattern[$i]['to'] === 'parenthesis_closer') { $found .= ')'; } else { $found .= '}'; } // Skip to the closing token. $stackPtr = ($tokens[$next][$pattern[$i]['to']] + 1); }//end if } else if ($pattern[$i]['type'] === 'string') { if ($tokens[$stackPtr]['code'] !== T_STRING && $tokens[$stackPtr]['code'] !== T_FN ) { $hasError = true; } if ($stackPtr !== $lastAddedStackPtr) { $found .= 'abc'; $lastAddedStackPtr = $stackPtr; } $stackPtr++; } else if ($pattern[$i]['type'] === 'newline') { // Find the next token that contains a newline character. $newline = 0; for ($j = $stackPtr; $j < $phpcsFile->numTokens; $j++) { if (strpos($tokens[$j]['content'], $phpcsFile->eolChar) !== false) { $newline = $j; break; } } if ($newline === 0) { // We didn't find a newline character in the rest of the file. $next = ($phpcsFile->numTokens - 1); $hasError = true; } else { if ($this->ignoreComments === false) { // The newline character cannot be part of a comment. if (isset(Tokens::$commentTokens[$tokens[$newline]['code']]) === true) { $hasError = true; } } if ($newline === $stackPtr) { $next = ($stackPtr + 1); } else { // Check that there were no significant tokens that we // skipped over to find our newline character. $next = $phpcsFile->findNext( $ignoreTokens, $stackPtr, null, true ); if ($next < $newline) { // We skipped a non-ignored token. $hasError = true; } else { $next = ($newline + 1); } } }//end if if ($stackPtr !== $lastAddedStackPtr) { $found .= $phpcsFile->getTokensAsString( $stackPtr, ($next - $stackPtr) ); $lastAddedStackPtr = ($next - 1); } $stackPtr = $next; }//end if }//end for if ($hasError === true) { $error = $this->prepareError($found, $patternCode); $errors[$origStackPtr] = $error; } return $errors; }//end processPattern() /** * Prepares an error for the specified patternCode. * * @param string $found The actual found string in the code. * @param string $patternCode The expected pattern code. * * @return string The error message. */ protected function prepareError($found, $patternCode) { $found = str_replace("\r\n", '\n', $found); $found = str_replace("\n", '\n', $found); $found = str_replace("\r", '\n', $found); $found = str_replace("\t", '\t', $found); $found = str_replace('EOL', '\n', $found); $expected = str_replace('EOL', '\n', $patternCode); $error = "Expected \"$expected\"; found \"$found\""; return $error; }//end prepareError() /** * Returns the patterns that should be checked. * * @return string[] */ abstract protected function getPatterns(); /** * Registers any supplementary tokens that this test might wish to process. * * A sniff may wish to register supplementary tests when it wishes to group * an arbitrary validation that cannot be performed using a pattern, with * other pattern tests. * * @return int[] * @see processSupplementary() */ protected function registerSupplementary() { return []; }//end registerSupplementary() /** * Processes any tokens registered with registerSupplementary(). * * @param \PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where to * process the skip. * @param int $stackPtr The position in the tokens stack to * process. * * @return void * @see registerSupplementary() */ protected function processSupplementary(File $phpcsFile, $stackPtr) { }//end processSupplementary() /** * Parses a pattern string into an array of pattern steps. * * @param string $pattern The pattern to parse. * * @return array The parsed pattern array. * @see createSkipPattern() * @see createTokenPattern() */ private function parse($pattern) { $patterns = []; $length = strlen($pattern); $lastToken = 0; $firstToken = 0; for ($i = 0; $i < $length; $i++) { $specialPattern = false; $isLastChar = ($i === ($length - 1)); $oldFirstToken = $firstToken; if (substr($pattern, $i, 3) === '...') { // It's a skip pattern. The skip pattern requires the // content of the token in the "from" position and the token // to skip to. $specialPattern = $this->createSkipPattern($pattern, ($i - 1)); $lastToken = ($i - $firstToken); $firstToken = ($i + 3); $i += 2; if ($specialPattern['to'] !== 'unknown') { $firstToken++; } } else if (substr($pattern, $i, 3) === 'abc') { $specialPattern = ['type' => 'string']; $lastToken = ($i - $firstToken); $firstToken = ($i + 3); $i += 2; } else if (substr($pattern, $i, 3) === 'EOL') { $specialPattern = ['type' => 'newline']; $lastToken = ($i - $firstToken); $firstToken = ($i + 3); $i += 2; }//end if if ($specialPattern !== false || $isLastChar === true) { // If we are at the end of the string, don't worry about a limit. if ($isLastChar === true) { // Get the string from the end of the last skip pattern, if any, // to the end of the pattern string. $str = substr($pattern, $oldFirstToken); } else { // Get the string from the end of the last special pattern, // if any, to the start of this special pattern. if ($lastToken === 0) { // Note that if the last special token was zero characters ago, // there will be nothing to process so we can skip this bit. // This happens if you have something like: EOL... in your pattern. $str = ''; } else { $str = substr($pattern, $oldFirstToken, $lastToken); } } if ($str !== '') { $tokenPatterns = $this->createTokenPattern($str); foreach ($tokenPatterns as $tokenPattern) { $patterns[] = $tokenPattern; } } // Make sure we don't skip the last token. if ($isLastChar === false && $i === ($length - 1)) { $i--; } }//end if // Add the skip pattern *after* we have processed // all the tokens from the end of the last skip pattern // to the start of this skip pattern. if ($specialPattern !== false) { $patterns[] = $specialPattern; } }//end for return $patterns; }//end parse() /** * Creates a skip pattern. * * @param string $pattern The pattern being parsed. * @param string $from The token content that the skip pattern starts from. * * @return array The pattern step. * @see createTokenPattern() * @see parse() */ private function createSkipPattern($pattern, $from) { $skip = ['type' => 'skip']; $nestedParenthesis = 0; $nestedBraces = 0; for ($start = $from; $start >= 0; $start--) { switch ($pattern[$start]) { case '(': if ($nestedParenthesis === 0) { $skip['to'] = 'parenthesis_closer'; } $nestedParenthesis--; break; case '{': if ($nestedBraces === 0) { $skip['to'] = 'scope_closer'; } $nestedBraces--; break; case '}': $nestedBraces++; break; case ')': $nestedParenthesis++; break; }//end switch if (isset($skip['to']) === true) { break; } }//end for if (isset($skip['to']) === false) { $skip['to'] = 'unknown'; } return $skip; }//end createSkipPattern() /** * Creates a token pattern. * * @param string $str The tokens string that the pattern should match. * * @return array The pattern step. * @see createSkipPattern() * @see parse() */ private function createTokenPattern($str) { // Don't add a space after the closing php tag as it will add a new // whitespace token. $tokenizer = new PHP('', null); // Remove the getTokens(); $tokens = array_slice($tokens, 1, (count($tokens) - 2)); $patterns = []; foreach ($tokens as $patternInfo) { $patterns[] = [ 'type' => 'token', 'token' => $patternInfo['code'], 'value' => $patternInfo['content'], ]; } return $patterns; }//end createTokenPattern() }//end class PHP_CodeSniffer-3.5.4/src/Sniffs/AbstractScopeSniff.php0000644000076500000240000001522413614652361022573 0ustar gsherwoodstaff * class ClassScopeTest extends PHP_CodeSniffer_Standards_AbstractScopeSniff * { * public function __construct() * { * parent::__construct(array(T_CLASS), array(T_FUNCTION)); * } * * protected function processTokenWithinScope(\PHP_CodeSniffer\Files\File $phpcsFile, $stackPtr, $currScope) * { * $className = $phpcsFile->getDeclarationName($currScope); * echo 'encountered a method within class '.$className; * } * } * * * @author Greg Sherwood * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Sniffs; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Exceptions\RuntimeException; abstract class AbstractScopeSniff implements Sniff { /** * The token types that this test wishes to listen to within the scope. * * @var array */ private $tokens = []; /** * The type of scope opener tokens that this test wishes to listen to. * * @var string */ private $scopeTokens = []; /** * True if this test should fire on tokens outside of the scope. * * @var boolean */ private $listenOutside = false; /** * Constructs a new AbstractScopeTest. * * @param array $scopeTokens The type of scope the test wishes to listen to. * @param array $tokens The tokens that the test wishes to listen to * within the scope. * @param boolean $listenOutside If true this test will also alert the * extending class when a token is found outside * the scope, by calling the * processTokenOutsideScope method. * * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If the specified tokens arrays are empty * or invalid. */ public function __construct( array $scopeTokens, array $tokens, $listenOutside=false ) { if (empty($scopeTokens) === true) { $error = 'The scope tokens list cannot be empty'; throw new RuntimeException($error); } if (empty($tokens) === true) { $error = 'The tokens list cannot be empty'; throw new RuntimeException($error); } $invalidScopeTokens = array_intersect($scopeTokens, $tokens); if (empty($invalidScopeTokens) === false) { $invalid = implode(', ', $invalidScopeTokens); $error = "Scope tokens [$invalid] can't be in the tokens array"; throw new RuntimeException($error); } $this->listenOutside = $listenOutside; $this->scopeTokens = array_flip($scopeTokens); $this->tokens = $tokens; }//end __construct() /** * The method that is called to register the tokens this test wishes to * listen to. * * DO NOT OVERRIDE THIS METHOD. Use the constructor of this class to register * for the desired tokens and scope. * * @return int[] * @see __constructor() */ final public function register() { return $this->tokens; }//end register() /** * Processes the tokens that this test is listening for. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param int $stackPtr The position in the stack where this * token was found. * * @return void|int Optionally returns a stack pointer. The sniff will not be * called again on the current file until the returned stack * pointer is reached. Return ($phpcsFile->numTokens + 1) to skip * the rest of the file. * @see processTokenWithinScope() */ final public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $foundScope = false; $skipTokens = []; foreach ($tokens[$stackPtr]['conditions'] as $scope => $code) { if (isset($this->scopeTokens[$code]) === true) { $skipTokens[] = $this->processTokenWithinScope($phpcsFile, $stackPtr, $scope); $foundScope = true; } } if ($this->listenOutside === true && $foundScope === false) { $skipTokens[] = $this->processTokenOutsideScope($phpcsFile, $stackPtr); } if (empty($skipTokens) === false) { return min($skipTokens); } return; }//end process() /** * Processes a token that is found within the scope that this test is * listening to. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param int $stackPtr The position in the stack where this * token was found. * @param int $currScope The position in the tokens array that * opened the scope that this test is * listening for. * * @return void|int Optionally returns a stack pointer. The sniff will not be * called again on the current file until the returned stack * pointer is reached. Return ($phpcsFile->numTokens + 1) to skip * the rest of the file. */ abstract protected function processTokenWithinScope(File $phpcsFile, $stackPtr, $currScope); /** * Processes a token that is found outside the scope that this test is * listening to. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param int $stackPtr The position in the stack where this * token was found. * * @return void|int Optionally returns a stack pointer. The sniff will not be * called again on the current file until the returned stack * pointer is reached. Return (count($tokens) + 1) to skip * the rest of the file. */ abstract protected function processTokenOutsideScope(File $phpcsFile, $stackPtr); }//end class PHP_CodeSniffer-3.5.4/src/Sniffs/AbstractVariableSniff.php0000644000076500000240000002156713614652361023256 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Sniffs; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Util\Tokens; abstract class AbstractVariableSniff extends AbstractScopeSniff { /** * List of PHP Reserved variables. * * Used by various naming convention sniffs. * * @var array */ protected $phpReservedVars = [ '_SERVER' => true, '_GET' => true, '_POST' => true, '_REQUEST' => true, '_SESSION' => true, '_ENV' => true, '_COOKIE' => true, '_FILES' => true, 'GLOBALS' => true, 'http_response_header' => true, 'HTTP_RAW_POST_DATA' => true, 'php_errormsg' => true, ]; /** * Constructs an AbstractVariableTest. */ public function __construct() { $scopes = Tokens::$ooScopeTokens; $listen = [ T_VARIABLE, T_DOUBLE_QUOTED_STRING, T_HEREDOC, ]; parent::__construct($scopes, $listen, true); }//end __construct() /** * Processes the token in the specified PHP_CodeSniffer\Files\File. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where this * token was found. * @param int $stackPtr The position where the token was found. * @param int $currScope The current scope opener token. * * @return void|int Optionally returns a stack pointer. The sniff will not be * called again on the current file until the returned stack * pointer is reached. Return ($phpcsFile->numTokens + 1) to skip * the rest of the file. */ final protected function processTokenWithinScope(File $phpcsFile, $stackPtr, $currScope) { $tokens = $phpcsFile->getTokens(); if ($tokens[$stackPtr]['code'] === T_DOUBLE_QUOTED_STRING || $tokens[$stackPtr]['code'] === T_HEREDOC ) { // Check to see if this string has a variable in it. $pattern = '|(?processVariableInString($phpcsFile, $stackPtr); } return; } // If this token is nested inside a function at a deeper // level than the current OO scope that was found, it's a normal // variable and not a member var. $conditions = array_reverse($tokens[$stackPtr]['conditions'], true); $inFunction = false; foreach ($conditions as $scope => $code) { if (isset(Tokens::$ooScopeTokens[$code]) === true) { break; } if ($code === T_FUNCTION || $code === T_CLOSURE) { $inFunction = true; } } if ($scope !== $currScope) { // We found a closer scope to this token, so ignore // this particular time through the sniff. We will process // this token when this closer scope is found to avoid // duplicate checks. return; } // Just make sure this isn't a variable in a function declaration. if ($inFunction === false && isset($tokens[$stackPtr]['nested_parenthesis']) === true) { foreach ($tokens[$stackPtr]['nested_parenthesis'] as $opener => $closer) { if (isset($tokens[$opener]['parenthesis_owner']) === false) { // Check if this is a USE statement for a closure. $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($opener - 1), null, true); if ($tokens[$prev]['code'] === T_USE) { $inFunction = true; break; } continue; } $owner = $tokens[$opener]['parenthesis_owner']; if ($tokens[$owner]['code'] === T_FUNCTION || $tokens[$owner]['code'] === T_CLOSURE ) { $inFunction = true; break; } } }//end if if ($inFunction === true) { return $this->processVariable($phpcsFile, $stackPtr); } else { return $this->processMemberVar($phpcsFile, $stackPtr); } }//end processTokenWithinScope() /** * Processes the token outside the scope in the file. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where this * token was found. * @param int $stackPtr The position where the token was found. * * @return void|int Optionally returns a stack pointer. The sniff will not be * called again on the current file until the returned stack * pointer is reached. Return ($phpcsFile->numTokens + 1) to skip * the rest of the file. */ final protected function processTokenOutsideScope(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // These variables are not member vars. if ($tokens[$stackPtr]['code'] === T_VARIABLE) { return $this->processVariable($phpcsFile, $stackPtr); } else if ($tokens[$stackPtr]['code'] === T_DOUBLE_QUOTED_STRING || $tokens[$stackPtr]['code'] === T_HEREDOC ) { // Check to see if this string has a variable in it. $pattern = '|(?processVariableInString($phpcsFile, $stackPtr); } } }//end processTokenOutsideScope() /** * Called to process class member vars. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where this * token was found. * @param int $stackPtr The position where the token was found. * * @return void|int Optionally returns a stack pointer. The sniff will not be * called again on the current file until the returned stack * pointer is reached. Return ($phpcsFile->numTokens + 1) to skip * the rest of the file. */ abstract protected function processMemberVar(File $phpcsFile, $stackPtr); /** * Called to process normal member vars. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where this * token was found. * @param int $stackPtr The position where the token was found. * * @return void|int Optionally returns a stack pointer. The sniff will not be * called again on the current file until the returned stack * pointer is reached. Return ($phpcsFile->numTokens + 1) to skip * the rest of the file. */ abstract protected function processVariable(File $phpcsFile, $stackPtr); /** * Called to process variables found in double quoted strings or heredocs. * * Note that there may be more than one variable in the string, which will * result only in one call for the string or one call per line for heredocs. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where this * token was found. * @param int $stackPtr The position where the double quoted * string was found. * * @return void|int Optionally returns a stack pointer. The sniff will not be * called again on the current file until the returned stack * pointer is reached. Return ($phpcsFile->numTokens + 1) to skip * the rest of the file. */ abstract protected function processVariableInString(File $phpcsFile, $stackPtr); }//end class PHP_CodeSniffer-3.5.4/src/Sniffs/Sniff.php0000644000076500000240000000535513614652361020121 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Sniffs; use PHP_CodeSniffer\Files\File; interface Sniff { /** * Registers the tokens that this sniff wants to listen for. * * An example return value for a sniff that wants to listen for whitespace * and any comments would be: * * * return array( * T_WHITESPACE, * T_DOC_COMMENT, * T_COMMENT, * ); * * * @return mixed[] * @see Tokens.php */ public function register(); /** * Called when one of the token types that this sniff is listening for * is found. * * The stackPtr variable indicates where in the stack the token was found. * A sniff can acquire information this token, along with all the other * tokens within the stack by first acquiring the token stack: * * * $tokens = $phpcsFile->getTokens(); * echo 'Encountered a '.$tokens[$stackPtr]['type'].' token'; * echo 'token information: '; * print_r($tokens[$stackPtr]); * * * If the sniff discovers an anomaly in the code, they can raise an error * by calling addError() on the \PHP_CodeSniffer\Files\File object, specifying an error * message and the position of the offending token: * * * $phpcsFile->addError('Encountered an error', $stackPtr); * * * @param \PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where the * token was found. * @param int $stackPtr The position in the PHP_CodeSniffer * file's token stack where the token * was found. * * @return void|int Optionally returns a stack pointer. The sniff will not be * called again on the current file until the returned stack * pointer is reached. Return (count($tokens) + 1) to skip * the rest of the file. */ public function process(File $phpcsFile, $stackPtr); }//end interface PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Arrays/DisallowLongArraySyntaxStandard.xml0000644000076500000240000000100013614652361031531 0ustar gsherwoodstaff [ 'foo' => 'bar', ]; ]]> array( 'foo' => 'bar', ); ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Arrays/DisallowShortArraySyntaxStandard.xml0000644000076500000240000000077613614652361031754 0ustar gsherwoodstaff array( 'foo' => 'bar', ); ]]> [ 'foo' => 'bar', ]; ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Classes/DuplicateClassNameStandard.xml0000644000076500000240000000105313614652361030572 0ustar gsherwoodstaff Foo { } ]]> Foo { } class Foo { } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Classes/OpeningBraceSameLineStandard.xml0000644000076500000240000000131013614652361031037 0ustar gsherwoodstaff { } ]]> { } ]]> // Start of class. } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Debug/CSSLintStandard.xml0000644000076500000240000000073113614652361026003 0ustar gsherwoodstaff %; } ]]> %; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Debug/ClosureLinterStandard.xml0000644000076500000240000000075313614652361027322 0ustar gsherwoodstaff ]; ]]> ,]; ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Debug/JSHintStandard.xml0000644000076500000240000000072513614652361025666 0ustar gsherwoodstaff var foo = 5; ]]> foo = 5; ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Commenting/FixmeStandard.xml0000644000076500000240000000102313614652361026641 0ustar gsherwoodstaff Handle strange case if ($test) { $var = 1; } ]]> FIXME: This needs to be fixed! if ($test) { $var = 1; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Commenting/TodoStandard.xml0000644000076500000240000000101613614652361026500 0ustar gsherwoodstaff Handle strange case if ($test) { $var = 1; } ]]> TODO: This needs to be fixed! if ($test) { $var = 1; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/CodeAnalysis/JumbledIncrementerStandard.xml0000644000076500000240000000124313614652361031631 0ustar gsherwoodstaff $i++) { for ($j = 0; $j < 10; $j++) { } } ]]> $i++) { for ($j = 0; $j < 10; $i++) { } } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/CodeAnalysis/UnusedFunctionParameterStandard.xml0000644000076500000240000000113113614652361032661 0ustar gsherwoodstaff $a + $b + $c; } ]]> $a + $b; } ]]> ././@LongLink0000000000000000000000000000014500000000000007755 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/ControlStructures/DisallowYodaConditionsStandard.xmlPHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/ControlStructures/DisallowYodaConditionsStandard.xm0000644000076500000240000000110213614652361033464 0ustar gsherwoodstaff { $var = 1; } ]]> { $var = 1; } ]]> ././@LongLink0000000000000000000000000000014500000000000007755 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/ControlStructures/InlineControlStructureStandard.xmlPHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/ControlStructures/InlineControlStructureStandard.xm0000644000076500000240000000101613614652361033543 0ustar gsherwoodstaff { $var = 1; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/CodeAnalysis/AssignmentInConditionStandard.xml0000644000076500000240000000110613614652361032317 0ustar gsherwoodstaff $test === 'abc') { // Code. } ]]> $test = 'abc') { // Code. } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/CodeAnalysis/EmptyStatementStandard.xml0000644000076500000240000000104513614652361031036 0ustar gsherwoodstaff // do nothing } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/CodeAnalysis/ForLoopShouldBeWhileLoopStandard.xml0000644000076500000240000000121613614652361032704 0ustar gsherwoodstaff $i = 0; $i < 10; $i++) { echo "{$i}\n"; } ]]> ;$test;) { $test = doSomething(); } ]]> ././@LongLink0000000000000000000000000000014500000000000007755 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/CodeAnalysis/ForLoopWithTestFunctionCallStandard.xmlPHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/CodeAnalysis/ForLoopWithTestFunctionCallStandard.xm0000644000076500000240000000135213614652361033256 0ustar gsherwoodstaff $end = count($foo); for ($i = 0; $i < $end; $i++) { echo $foo[$i]."\n"; } ]]> count($foo); $i++) { echo $foo[$i]."\n"; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/CodeAnalysis/UnconditionalIfStatementStandard.xml0000644000076500000240000000162613614652361033032 0ustar gsherwoodstaff $test) { $var = 1; } ]]> true) { $var = 1; } ]]> $test) { $var = 1; } ]]> false) { $var = 1; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/CodeAnalysis/UnnecessaryFinalModifierStandard.xml0000644000076500000240000000116713614652361033010 0ustar gsherwoodstaff final function bar() { } } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/CodeAnalysis/UselessOverridingMethodStandard.xml0000644000076500000240000000130313614652361032665 0ustar gsherwoodstaff $this->doSomethingElse(); } } ]]> parent::bar(); } } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Files/ByteOrderMarkStandard.xml0000644000076500000240000000040613614652361027251 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Files/EndFileNewlineStandard.xml0000644000076500000240000000024113614652361027364 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Files/EndFileNoNewlineStandard.xml0000644000076500000240000000025013614652361027661 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Files/ExecutableFileStandard.xml0000644000076500000240000000022313614652361027415 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Files/InlineHTMLStandard.xml0000644000076500000240000000112313614652361026437 0ustar gsherwoodstaff some string here PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Files/LineEndingsStandard.xml0000644000076500000240000000025713614652361026742 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Files/LineLengthStandard.xml0000644000076500000240000000031713614652361026571 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Files/LowercasedFilenameStandard.xml0000644000076500000240000000023113614652361030264 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Files/OneClassPerFileStandard.xml0000644000076500000240000000100213614652361027506 0ustar gsherwoodstaff class Foo { } ]]> class Foo { } class Bar { } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Files/OneInterfacePerFileStandard.xml0000644000076500000240000000103513614652361030347 0ustar gsherwoodstaff interface Foo { } ]]> interface Foo { } interface Bar { } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Files/OneObjectStructurePerFileStandard.xml0000644000076500000240000000107013614652361031575 0ustar gsherwoodstaff trait Foo { } ]]> trait Foo { } class Bar { } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Files/OneTraitPerFileStandard.xml0000644000076500000240000000100113614652361027523 0ustar gsherwoodstaff trait Foo { } ]]> trait Foo { } trait Bar { } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Formatting/DisallowMultipleStatementsStandard.xml0000644000076500000240000000101413614652361033145 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Formatting/MultipleStatementAlignmentStandard.xml0000644000076500000240000000327713614652361033137 0ustar gsherwoodstaff = (1 + 2); $veryLongVarName = 'string'; $var = foo($bar, $baz); ]]> = (1 + 2); $veryLongVarName = 'string'; $var = foo($bar, $baz); ]]> += 1; $veryLongVarName = 1; ]]> += 1; $veryLongVarName = 1; ]]> = 1; $veryLongVarName -= 1; ]]> = 1; $veryLongVarName -= 1; ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Formatting/NoSpaceAfterCastStandard.xml0000644000076500000240000000076513614652361030744 0ustar gsherwoodstaff 1; ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Formatting/SpaceAfterCastStandard.xml0000644000076500000240000000076613614652361030450 0ustar gsherwoodstaff 1; ]]> 1; ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Formatting/SpaceAfterNotStandard.xml0000644000076500000240000000144013614652361030304 0ustar gsherwoodstaff $someVar || ! $x instanceOf stdClass) {}; ]]> $someVar || !$x instanceOf stdClass) {}; ]]> $someVar || ! $x instanceOf stdClass) {}; ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Functions/CallTimePassByReferenceStandard.xml0000644000076500000240000000123113614652361032075 0ustar gsherwoodstaff &$bar) { $bar++; } $baz = 1; foo($baz); ]]> &$baz); ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Functions/FunctionCallArgumentSpacingStandard.xml0000644000076500000240000000174513614652361033045 0ustar gsherwoodstaff $baz) { } ]]> $baz) { } ]]> = true) { } ]]> =true) { } ]]> ././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Functions/OpeningFunctionBraceBsdAllmanStandard.xmlPHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Functions/OpeningFunctionBraceBsdAllmanStandard.xml0000644000076500000240000000126713614652361033273 0ustar gsherwoodstaff { ... } ]]> { ... } ]]> ././@LongLink0000000000000000000000000000015300000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Functions/OpeningFunctionBraceKernighanRitchieStandard.xmlPHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Functions/OpeningFunctionBraceKernighanRitchieStand0000644000076500000240000000126513614652361033364 0ustar gsherwoodstaff { ... } ]]> { ... } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Metrics/CyclomaticComplexityStandard.xml0000644000076500000240000000035413614652361031252 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Metrics/NestingLevelStandard.xml0000644000076500000240000000031313614652361027477 0ustar gsherwoodstaff ././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/NamingConventions/CamelCapsFunctionNameStandard.xmlPHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/NamingConventions/CamelCapsFunctionNameStandard.xml0000644000076500000240000000110313614652361033266 0ustar gsherwoodstaff doSomething() { } ]]> do_something() { } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/NamingConventions/ConstructorNameStandard.xml0000644000076500000240000000110113614652361032253 0ustar gsherwoodstaff __construct() { } } ]]> Foo() { } } ]]> ././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/NamingConventions/UpperCaseConstantNameStandard.xmlPHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/NamingConventions/UpperCaseConstantNameStandard.xml0000644000076500000240000000115213614652361033335 0ustar gsherwoodstaff FOO_CONSTANT', 'foo'); class FooClass { const FOO_CONSTANT = 'foo'; } ]]> Foo_Constant', 'foo'); class FooClass { const foo_constant = 'foo'; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/PHP/BacktickOperatorStandard.xml0000644000076500000240000000027713614652361027361 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/PHP/CharacterBeforePHPOpeningTagStandard.xml0000644000076500000240000000104113614652361031463 0ustar gsherwoodstaff Beginning content PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/PHP/ClosingPHPTagStandard.xml0000644000076500000240000000102213614652361026521 0ustar gsherwoodstaff echo 'Foo'; ?> ]]> echo 'Foo'; ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/PHP/DeprecatedFunctionsStandard.xml0000644000076500000240000000075713614652361030066 0ustar gsherwoodstaff explode('a', $bar); ]]> split('a', $bar); ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/PHP/DisallowAlternativePHPTagsStandard.xml0000644000076500000240000000052513614652361031272 0ustar gsherwoodstaff to delimit PHP code, do not use the ASP <% %> style tags nor the tags. This is the most portable way to include PHP code on differing operating systems and setups. ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/PHP/DisallowRequestSuperglobalStandard.xml0000644000076500000240000000040513614652361031452 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/PHP/DisallowShortOpenTagStandard.xml0000644000076500000240000000041713614652361030202 0ustar gsherwoodstaff to delimit PHP code, not the shorthand. This is the most portable way to include PHP code on differing operating systems and setups. ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/PHP/DiscourageGotoStandard.xml0000644000076500000240000000024013614652361027036 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/PHP/ForbiddenFunctionsStandard.xml0000644000076500000240000000076213614652361027716 0ustar gsherwoodstaff count($bar); ]]> sizeof($bar); ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/PHP/LowerCaseConstantStandard.xml0000644000076500000240000000115313614652361027522 0ustar gsherwoodstaff true, false and null constants must always be lowercase. ]]> false || $var === null) { $var = true; } ]]> FALSE || $var === NULL) { $var = TRUE; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/PHP/LowerCaseKeywordStandard.xml0000644000076500000240000000072413614652361027360 0ustar gsherwoodstaff array(); ]]> Array(); ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/PHP/LowerCaseTypeStandard.xml0000644000076500000240000000174513614652361026661 0ustar gsherwoodstaff Int $foo) : STRING { } ]]> (BOOL) $isValid; ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/PHP/NoSilencedErrorsStandard.xml0000644000076500000240000000104313614652361027342 0ustar gsherwoodstaff isset($foo) && $foo) { echo "Hello\n"; } ]]> @$foo) { echo "Hello\n"; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/PHP/SAPIUsageStandard.xml0000644000076500000240000000105313614652361025644 0ustar gsherwoodstaff PHP_SAPI === 'cli') { echo "Hello, CLI user."; } ]]> php_sapi_name() === 'cli') { echo "Hello, CLI user."; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/PHP/UpperCaseConstantStandard.xml0000644000076500000240000000115313614652361027525 0ustar gsherwoodstaff true, false and null constants must always be uppercase. ]]> FALSE || $var === NULL) { $var = TRUE; } ]]> false || $var === null) { $var = true; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/Strings/UnnecessaryStringConcatStandard.xml0000644000076500000240000000101613614652361031742 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/VersionControl/SubversionPropertiesStandard.xml0000644000076500000240000000042313614652361032676 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/WhiteSpace/ArbitraryParenthesesSpacingStandard.xml0000644000076500000240000000131713614652361033201 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/WhiteSpace/DisallowSpaceIndentStandard.xml0000644000076500000240000000025613614652361031430 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/WhiteSpace/DisallowTabIndentStandard.xml0000644000076500000240000000025413614652361031101 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/WhiteSpace/ScopeIndentStandard.xml0000644000076500000240000000110613614652361027742 0ustar gsherwoodstaff $var = 1; } ]]> $var = 1; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Docs/WhiteSpace/SpreadOperatorSpacingAfterStandard.xml0000644000076500000240000000164613614652361032761 0ustar gsherwoodstaff &...$spread) { bar(...$spread); bar( [...$foo], ...array_values($keyedArray) ); } ]]> ... $spread) { bar(... $spread ); bar( [... $foo ],.../*comment*/array_values($keyedArray) ); } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Arrays/ArrayIndentSniff.php0000644000076500000240000001243513614652361027017 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Arrays; use PHP_CodeSniffer\Sniffs\AbstractArraySniff; use PHP_CodeSniffer\Util\Tokens; class ArrayIndentSniff extends AbstractArraySniff { /** * The number of spaces each array key should be indented. * * @var integer */ public $indent = 4; /** * Processes a single-line array definition. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being checked. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param int $arrayStart The token that starts the array definition. * @param int $arrayEnd The token that ends the array definition. * @param array $indices An array of token positions for the array keys, * double arrows, and values. * * @return void */ public function processSingleLineArray($phpcsFile, $stackPtr, $arrayStart, $arrayEnd, $indices) { }//end processSingleLineArray() /** * Processes a multi-line array definition. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being checked. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param int $arrayStart The token that starts the array definition. * @param int $arrayEnd The token that ends the array definition. * @param array $indices An array of token positions for the array keys, * double arrows, and values. * * @return void */ public function processMultiLineArray($phpcsFile, $stackPtr, $arrayStart, $arrayEnd, $indices) { $tokens = $phpcsFile->getTokens(); $first = $phpcsFile->findFirstOnLine(T_WHITESPACE, $stackPtr, true); $expectedIndent = ($tokens[$first]['column'] - 1 + $this->indent); foreach ($indices as $index) { if (isset($index['index_start']) === true) { $start = $index['index_start']; } else { $start = $index['value_start']; } $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($start - 1), null, true); if ($tokens[$prev]['line'] === $tokens[$start]['line']) { // This index isn't the only content on the line // so we can't check indent rules. continue; } $first = $phpcsFile->findFirstOnLine(T_WHITESPACE, $start, true); $foundIndent = ($tokens[$first]['column'] - 1); if ($foundIndent === $expectedIndent) { continue; } $error = 'Array key not indented correctly; expected %s spaces but found %s'; $data = [ $expectedIndent, $foundIndent, ]; $fix = $phpcsFile->addFixableError($error, $first, 'KeyIncorrect', $data); if ($fix === false) { continue; } $padding = str_repeat(' ', $expectedIndent); if ($foundIndent === 0) { $phpcsFile->fixer->addContentBefore($first, $padding); } else { $phpcsFile->fixer->replaceToken(($first - 1), $padding); } }//end foreach $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($arrayEnd - 1), null, true); if ($tokens[$prev]['line'] === $tokens[$arrayEnd]['line']) { $error = 'Closing brace of array declaration must be on a new line'; $fix = $phpcsFile->addFixableError($error, $arrayEnd, 'CloseBraceNotNewLine'); if ($fix === true) { $padding = $phpcsFile->eolChar.str_repeat(' ', $expectedIndent); $phpcsFile->fixer->addContentBefore($arrayEnd, $padding); } return; } // The close brace must be indented one stop less. $expectedIndent -= $this->indent; $foundIndent = ($tokens[$arrayEnd]['column'] - 1); if ($foundIndent === $expectedIndent) { return; } $error = 'Array close brace not indented correctly; expected %s spaces but found %s'; $data = [ $expectedIndent, $foundIndent, ]; $fix = $phpcsFile->addFixableError($error, $arrayEnd, 'CloseBraceIncorrect', $data); if ($fix === false) { return; } $padding = str_repeat(' ', $expectedIndent); if ($foundIndent === 0) { $phpcsFile->fixer->addContentBefore($arrayEnd, $padding); } else { $phpcsFile->fixer->replaceToken(($arrayEnd - 1), $padding); } }//end processMultiLineArray() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Arrays/DisallowLongArraySyntaxSniff.php0000644000076500000240000000437713614652361031411 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Arrays; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class DisallowLongArraySyntaxSniff implements Sniff { /** * Registers the tokens that this sniff wants to listen for. * * @return int[] */ public function register() { return [T_ARRAY]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $phpcsFile->recordMetric($stackPtr, 'Short array syntax used', 'no'); $error = 'Short array syntax must be used to define arrays'; if (isset($tokens[$stackPtr]['parenthesis_opener']) === false || isset($tokens[$stackPtr]['parenthesis_closer']) === false ) { // Live coding/parse error, just show the error, don't try and fix it. $phpcsFile->addError($error, $stackPtr, 'Found'); return; } $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Found'); if ($fix === true) { $opener = $tokens[$stackPtr]['parenthesis_opener']; $closer = $tokens[$stackPtr]['parenthesis_closer']; $phpcsFile->fixer->beginChangeset(); if ($opener === null) { $phpcsFile->fixer->replaceToken($stackPtr, '[]'); } else { $phpcsFile->fixer->replaceToken($stackPtr, ''); $phpcsFile->fixer->replaceToken($opener, '['); $phpcsFile->fixer->replaceToken($closer, ']'); } $phpcsFile->fixer->endChangeset(); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Arrays/DisallowShortArraySyntaxSniff.php0000644000076500000240000000334113614652361031577 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Arrays; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class DisallowShortArraySyntaxSniff implements Sniff { /** * Registers the tokens that this sniff wants to listen for. * * @return int[] */ public function register() { return [T_OPEN_SHORT_ARRAY]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $phpcsFile->recordMetric($stackPtr, 'Short array syntax used', 'yes'); $error = 'Short array syntax is not allowed'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Found'); if ($fix === true) { $tokens = $phpcsFile->getTokens(); $opener = $tokens[$stackPtr]['bracket_opener']; $closer = $tokens[$stackPtr]['bracket_closer']; $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->replaceToken($opener, 'array('); $phpcsFile->fixer->replaceToken($closer, ')'); $phpcsFile->fixer->endChangeset(); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Classes/DuplicateClassNameSniff.php0000644000076500000240000000726513614652361030441 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Classes; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class DuplicateClassNameSniff implements Sniff { /** * List of classes that have been found during checking. * * @var array */ protected $foundClasses = []; /** * Registers the tokens that this sniff wants to listen for. * * @return int[] */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $namespace = ''; $findTokens = [ T_CLASS, T_INTERFACE, T_TRAIT, T_NAMESPACE, T_CLOSE_TAG, ]; $stackPtr = $phpcsFile->findNext($findTokens, ($stackPtr + 1)); while ($stackPtr !== false) { if ($tokens[$stackPtr]['code'] === T_CLOSE_TAG) { // We can stop here. The sniff will continue from the next open // tag when PHPCS reaches that token, if there is one. return; } // Keep track of what namespace we are in. if ($tokens[$stackPtr]['code'] === T_NAMESPACE) { $nsEnd = $phpcsFile->findNext( [ T_NS_SEPARATOR, T_STRING, T_WHITESPACE, ], ($stackPtr + 1), null, true ); $namespace = trim($phpcsFile->getTokensAsString(($stackPtr + 1), ($nsEnd - $stackPtr - 1))); $stackPtr = $nsEnd; } else { $nameToken = $phpcsFile->findNext(T_STRING, $stackPtr); $name = $tokens[$nameToken]['content']; if ($namespace !== '') { $name = $namespace.'\\'.$name; } $compareName = strtolower($name); if (isset($this->foundClasses[$compareName]) === true) { $type = strtolower($tokens[$stackPtr]['content']); $file = $this->foundClasses[$compareName]['file']; $line = $this->foundClasses[$compareName]['line']; $error = 'Duplicate %s name "%s" found; first defined in %s on line %s'; $data = [ $type, $name, $file, $line, ]; $phpcsFile->addWarning($error, $stackPtr, 'Found', $data); } else { $this->foundClasses[$compareName] = [ 'file' => $phpcsFile->getFilename(), 'line' => $tokens[$stackPtr]['line'], ]; } }//end if $stackPtr = $phpcsFile->findNext($findTokens, ($stackPtr + 1)); }//end while }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Classes/OpeningBraceSameLineSniff.php0000644000076500000240000001100213614652361030672 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Classes; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class OpeningBraceSameLineSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_CLASS, T_INTERFACE, T_TRAIT, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $scopeIdentifier = $phpcsFile->findNext(T_STRING, ($stackPtr + 1)); $errorData = [strtolower($tokens[$stackPtr]['content']).' '.$tokens[$scopeIdentifier]['content']]; if (isset($tokens[$stackPtr]['scope_opener']) === false) { $error = 'Possible parse error: %s missing opening or closing brace'; $phpcsFile->addWarning($error, $stackPtr, 'MissingBrace', $errorData); return; } $openingBrace = $tokens[$stackPtr]['scope_opener']; // Is the brace on the same line as the class/interface/trait declaration ? $lastClassLineToken = $phpcsFile->findPrevious(T_WHITESPACE, ($openingBrace - 1), $stackPtr, true); $lastClassLine = $tokens[$lastClassLineToken]['line']; $braceLine = $tokens[$openingBrace]['line']; $lineDifference = ($braceLine - $lastClassLine); if ($lineDifference > 0) { $phpcsFile->recordMetric($stackPtr, 'Class opening brace placement', 'new line'); $error = 'Opening brace should be on the same line as the declaration for %s'; $fix = $phpcsFile->addFixableError($error, $openingBrace, 'BraceOnNewLine', $errorData); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->addContent($lastClassLineToken, ' {'); $phpcsFile->fixer->replaceToken($openingBrace, ''); $phpcsFile->fixer->endChangeset(); } } else { $phpcsFile->recordMetric($stackPtr, 'Class opening brace placement', 'same line'); } // Is the opening brace the last thing on the line ? $next = $phpcsFile->findNext(T_WHITESPACE, ($openingBrace + 1), null, true); if ($tokens[$next]['line'] === $tokens[$openingBrace]['line']) { if ($next === $tokens[$stackPtr]['scope_closer']) { // Ignore empty classes. return; } $error = 'Opening brace must be the last content on the line'; $fix = $phpcsFile->addFixableError($error, $openingBrace, 'ContentAfterBrace'); if ($fix === true) { $phpcsFile->fixer->addNewline($openingBrace); } } // Only continue checking if the opening brace looks good. if ($lineDifference > 0) { return; } // Is there precisely one space before the opening brace ? if ($tokens[($openingBrace - 1)]['code'] !== T_WHITESPACE) { $length = 0; } else if ($tokens[($openingBrace - 1)]['content'] === "\t") { $length = '\t'; } else { $length = $tokens[($openingBrace - 1)]['length']; } if ($length !== 1) { $error = 'Expected 1 space before opening brace; found %s'; $data = [$length]; $fix = $phpcsFile->addFixableError($error, $openingBrace, 'SpaceBeforeBrace', $data); if ($fix === true) { if ($length === 0 || $length === '\t') { $phpcsFile->fixer->addContentBefore($openingBrace, ' '); } else { $phpcsFile->fixer->replaceToken(($openingBrace - 1), ' '); } } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/CodeAnalysis/AssignmentInConditionSniff.php0000644000076500000240000001216713614652361032164 0ustar gsherwoodstaff * @copyright 2017 Juliette Reinders Folmer. All rights reserved. * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\CodeAnalysis; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class AssignmentInConditionSniff implements Sniff { /** * Assignment tokens to trigger on. * * Set in the register() method. * * @var array */ protected $assignmentTokens = []; /** * The tokens that indicate the start of a condition. * * @var array */ protected $conditionStartTokens = []; /** * Registers the tokens that this sniff wants to listen for. * * @return int[] */ public function register() { $this->assignmentTokens = Tokens::$assignmentTokens; unset($this->assignmentTokens[T_DOUBLE_ARROW]); $starters = Tokens::$booleanOperators; $starters[T_SEMICOLON] = T_SEMICOLON; $starters[T_OPEN_PARENTHESIS] = T_OPEN_PARENTHESIS; $this->conditionStartTokens = $starters; return [ T_IF, T_ELSEIF, T_FOR, T_SWITCH, T_CASE, T_WHILE, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $token = $tokens[$stackPtr]; // Find the condition opener/closer. if ($token['code'] === T_FOR) { if (isset($token['parenthesis_opener'], $token['parenthesis_closer']) === false) { return; } $semicolon = $phpcsFile->findNext(T_SEMICOLON, ($token['parenthesis_opener'] + 1), ($token['parenthesis_closer'])); if ($semicolon === false) { return; } $opener = $semicolon; $semicolon = $phpcsFile->findNext(T_SEMICOLON, ($opener + 1), ($token['parenthesis_closer'])); if ($semicolon === false) { return; } $closer = $semicolon; unset($semicolon); } else if ($token['code'] === T_CASE) { if (isset($token['scope_opener']) === false) { return; } $opener = $stackPtr; $closer = $token['scope_opener']; } else { if (isset($token['parenthesis_opener'], $token['parenthesis_closer']) === false) { return; } $opener = $token['parenthesis_opener']; $closer = $token['parenthesis_closer']; }//end if $startPos = $opener; do { $hasAssignment = $phpcsFile->findNext($this->assignmentTokens, ($startPos + 1), $closer); if ($hasAssignment === false) { return; } // Examine whether the left side is a variable. $hasVariable = false; $conditionStart = $startPos; $altConditionStart = $phpcsFile->findPrevious($this->conditionStartTokens, ($hasAssignment - 1), $startPos); if ($altConditionStart !== false) { $conditionStart = $altConditionStart; } for ($i = $hasAssignment; $i > $conditionStart; $i--) { if (isset(Tokens::$emptyTokens[$tokens[$i]['code']]) === true) { continue; } // If this is a variable or array, we've seen all we need to see. if ($tokens[$i]['code'] === T_VARIABLE || $tokens[$i]['code'] === T_CLOSE_SQUARE_BRACKET) { $hasVariable = true; break; } // If this is a function call or something, we are OK. if ($tokens[$i]['code'] === T_CLOSE_PARENTHESIS) { break; } } if ($hasVariable === true) { $errorCode = 'Found'; if ($token['code'] === T_WHILE) { $errorCode = 'FoundInWhileCondition'; } $phpcsFile->addWarning( 'Variable assignment found within a condition. Did you mean to do a comparison ?', $hasAssignment, $errorCode ); } $startPos = $hasAssignment; } while ($startPos < $closer); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/CodeAnalysis/EmptyPHPStatementSniff.php0000644000076500000240000001246013614652361031245 0ustar gsherwoodstaff * @copyright 2017 Juliette Reinders Folmer. All rights reserved. * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\CodeAnalysis; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class EmptyPHPStatementSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return int[] */ public function register() { return [ T_SEMICOLON, T_CLOSE_TAG, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); switch ($tokens[$stackPtr]['type']) { // Detect `something();;`. case 'T_SEMICOLON': $prevNonEmpty = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); if ($prevNonEmpty === false) { return; } if ($tokens[$prevNonEmpty]['code'] !== T_SEMICOLON && $tokens[$prevNonEmpty]['code'] !== T_OPEN_TAG && $tokens[$prevNonEmpty]['code'] !== T_OPEN_TAG_WITH_ECHO ) { if ($tokens[$prevNonEmpty]['code'] !== T_CLOSE_CURLY_BRACKET || isset($tokens[$prevNonEmpty]['scope_condition']) === false ) { return; } $scopeOwner = $tokens[$tokens[$prevNonEmpty]['scope_condition']]['code']; if ($scopeOwner === T_CLOSURE || $scopeOwner === T_ANON_CLASS) { return; } // Else, it's something like `if (foo) {};` and the semi-colon is not needed. } if (isset($tokens[$stackPtr]['nested_parenthesis']) === true) { $nested = $tokens[$stackPtr]['nested_parenthesis']; $lastCloser = array_pop($nested); if (isset($tokens[$lastCloser]['parenthesis_owner']) === true && $tokens[$tokens[$lastCloser]['parenthesis_owner']]['code'] === T_FOR ) { // Empty for() condition. return; } } $fix = $phpcsFile->addFixableWarning( 'Empty PHP statement detected: superfluous semi-colon.', $stackPtr, 'SemicolonWithoutCodeDetected' ); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); if ($tokens[$prevNonEmpty]['code'] === T_OPEN_TAG || $tokens[$prevNonEmpty]['code'] === T_OPEN_TAG_WITH_ECHO ) { // Check for superfluous whitespace after the semi-colon which will be // removed as the `fixer->replaceToken(($stackPtr + 1), $replacement); } } for ($i = $stackPtr; $i > $prevNonEmpty; $i--) { if ($tokens[$i]['code'] !== T_SEMICOLON && $tokens[$i]['code'] !== T_WHITESPACE ) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); }//end if break; // Detect ``. case 'T_CLOSE_TAG': $prevNonEmpty = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true); if ($prevNonEmpty === false || ($tokens[$prevNonEmpty]['code'] !== T_OPEN_TAG && $tokens[$prevNonEmpty]['code'] !== T_OPEN_TAG_WITH_ECHO) ) { return; } $fix = $phpcsFile->addFixableWarning( 'Empty PHP open/close tag combination detected.', $prevNonEmpty, 'EmptyPHPOpenCloseTagsDetected' ); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = $prevNonEmpty; $i <= $stackPtr; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } break; default: // Deliberately left empty. break; }//end switch }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/CodeAnalysis/EmptyStatementSniff.php0000644000076500000240000000455013614652361030676 0ustar gsherwoodstaff * stmt { * // foo * } * stmt (conditions) { * // foo * } * * * @author Manuel Pichler * @author Greg Sherwood * @copyright 2007-2014 Manuel Pichler. All rights reserved. * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\CodeAnalysis; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class EmptyStatementSniff implements Sniff { /** * Registers the tokens that this sniff wants to listen for. * * @return int[] */ public function register() { return [ T_TRY, T_CATCH, T_FINALLY, T_DO, T_ELSE, T_ELSEIF, T_FOR, T_FOREACH, T_IF, T_SWITCH, T_WHILE, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $token = $tokens[$stackPtr]; // Skip statements without a body. if (isset($token['scope_opener']) === false) { return; } $next = $phpcsFile->findNext( Tokens::$emptyTokens, ($token['scope_opener'] + 1), ($token['scope_closer'] - 1), true ); if ($next !== false) { return; } // Get token identifier. $name = strtoupper($token['content']); $error = 'Empty %s statement detected'; $phpcsFile->addError($error, $stackPtr, 'Detected'.ucfirst(strtolower($name)), [$name]); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/CodeAnalysis/ForLoopShouldBeWhileLoopSniff.php0000644000076500000240000000450213614652361032541 0ustar gsherwoodstaff * class Foo * { * public function bar($x) * { * for (;true;) true; // No Init or Update part, may as well be: while (true) * } * } * * * @author Manuel Pichler * @copyright 2007-2014 Manuel Pichler. All rights reserved. * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\CodeAnalysis; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class ForLoopShouldBeWhileLoopSniff implements Sniff { /** * Registers the tokens that this sniff wants to listen for. * * @return int[] */ public function register() { return [T_FOR]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $token = $tokens[$stackPtr]; // Skip invalid statement. if (isset($token['parenthesis_opener']) === false) { return; } $next = ++$token['parenthesis_opener']; $end = --$token['parenthesis_closer']; $parts = [ 0, 0, 0, ]; $index = 0; for (; $next <= $end; ++$next) { $code = $tokens[$next]['code']; if ($code === T_SEMICOLON) { ++$index; } else if (isset(Tokens::$emptyTokens[$code]) === false) { ++$parts[$index]; } } if ($parts[0] === 0 && $parts[2] === 0 && $parts[1] > 0) { $error = 'This FOR loop can be simplified to a WHILE loop'; $phpcsFile->addWarning($error, $stackPtr, 'CanSimplify'); } }//end process() }//end class ././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/CodeAnalysis/ForLoopWithTestFunctionCallSniff.phpPHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/CodeAnalysis/ForLoopWithTestFunctionCallSniff.php0000644000076500000240000000533313614652361033271 0ustar gsherwoodstaff * class Foo * { * public function bar($x) * { * $a = array(1, 2, 3, 4); * for ($i = 0; $i < count($a); $i++) { * $a[$i] *= $i; * } * } * } * * * @author Greg Sherwood * @author Manuel Pichler * @copyright 2007-2014 Manuel Pichler. All rights reserved. * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\CodeAnalysis; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class ForLoopWithTestFunctionCallSniff implements Sniff { /** * Registers the tokens that this sniff wants to listen for. * * @return int[] */ public function register() { return [T_FOR]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $token = $tokens[$stackPtr]; // Skip invalid statement. if (isset($token['parenthesis_opener']) === false) { return; } $next = ++$token['parenthesis_opener']; $end = --$token['parenthesis_closer']; $position = 0; for (; $next <= $end; ++$next) { $code = $tokens[$next]['code']; if ($code === T_SEMICOLON) { ++$position; } if ($position < 1) { continue; } else if ($position > 1) { break; } else if ($code !== T_VARIABLE && $code !== T_STRING) { continue; } // Find next non empty token, if it is a open curly brace we have a // function call. $index = $phpcsFile->findNext(Tokens::$emptyTokens, ($next + 1), null, true); if ($tokens[$index]['code'] === T_OPEN_PARENTHESIS) { $error = 'Avoid function calls in a FOR loop test part'; $phpcsFile->addWarning($error, $stackPtr, 'NotAllowed'); break; } }//end for }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/CodeAnalysis/JumbledIncrementerSniff.php0000644000076500000240000000720313614652361031467 0ustar gsherwoodstaff * class Foo * { * public function bar($x) * { * for ($i = 0; $i < 10; $i++) * { * for ($k = 0; $k < 20; $i++) * { * echo 'Hello'; * } * } * } * } * * * @author Manuel Pichler * @copyright 2007-2014 Manuel Pichler. All rights reserved. * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\CodeAnalysis; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class JumbledIncrementerSniff implements Sniff { /** * Registers the tokens that this sniff wants to listen for. * * @return int[] */ public function register() { return [T_FOR]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $token = $tokens[$stackPtr]; // Skip for-loop without body. if (isset($token['scope_opener']) === false) { return; } // Find incrementors for outer loop. $outer = $this->findIncrementers($tokens, $token); // Skip if empty. if (count($outer) === 0) { return; } // Find nested for loops. $start = ++$token['scope_opener']; $end = --$token['scope_closer']; for (; $start <= $end; ++$start) { if ($tokens[$start]['code'] !== T_FOR) { continue; } $inner = $this->findIncrementers($tokens, $tokens[$start]); $diff = array_intersect($outer, $inner); if (count($diff) !== 0) { $error = 'Loop incrementor (%s) jumbling with inner loop'; $data = [join(', ', $diff)]; $phpcsFile->addWarning($error, $stackPtr, 'Found', $data); } } }//end process() /** * Get all used variables in the incrementer part of a for statement. * * @param array(integer=>array) $tokens Array with all code sniffer tokens. * @param array(string=>mixed) $token Current for loop token * * @return string[] List of all found incrementer variables. */ protected function findIncrementers(array $tokens, array $token) { // Skip invalid statement. if (isset($token['parenthesis_opener']) === false) { return []; } $start = ++$token['parenthesis_opener']; $end = --$token['parenthesis_closer']; $incrementers = []; $semicolons = 0; for ($next = $start; $next <= $end; ++$next) { $code = $tokens[$next]['code']; if ($code === T_SEMICOLON) { ++$semicolons; } else if ($semicolons === 2 && $code === T_VARIABLE) { $incrementers[] = $tokens[$next]['content']; } } return $incrementers; }//end findIncrementers() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/CodeAnalysis/UnconditionalIfStatementSniff.php0000644000076500000240000000454513614652361032671 0ustar gsherwoodstafftrue or false * * * class Foo * { * public function close() * { * if (true) * { * // ... * } * } * } * * * @author Manuel Pichler * @copyright 2007-2014 Manuel Pichler. All rights reserved. * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\CodeAnalysis; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class UnconditionalIfStatementSniff implements Sniff { /** * Registers the tokens that this sniff wants to listen for. * * @return int[] */ public function register() { return [ T_IF, T_ELSEIF, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $token = $tokens[$stackPtr]; // Skip for-loop without body. if (isset($token['parenthesis_opener']) === false) { return; } $next = ++$token['parenthesis_opener']; $end = --$token['parenthesis_closer']; $goodCondition = false; for (; $next <= $end; ++$next) { $code = $tokens[$next]['code']; if (isset(Tokens::$emptyTokens[$code]) === true) { continue; } else if ($code !== T_TRUE && $code !== T_FALSE) { $goodCondition = true; } } if ($goodCondition === false) { $error = 'Avoid IF statements that are always true or false'; $phpcsFile->addWarning($error, $stackPtr, 'Found'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/CodeAnalysis/UnnecessaryFinalModifierSniff.php0000644000076500000240000000434513614652361032645 0ustar gsherwoodstaff * final class Foo * { * public final function bar() * { * } * } * * * @author Manuel Pichler * @copyright 2007-2014 Manuel Pichler. All rights reserved. * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\CodeAnalysis; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class UnnecessaryFinalModifierSniff implements Sniff { /** * Registers the tokens that this sniff wants to listen for. * * @return int[] */ public function register() { return [T_CLASS]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $token = $tokens[$stackPtr]; // Skip for-statements without body. if (isset($token['scope_opener']) === false) { return; } // Fetch previous token. $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); // Skip for non final class. if ($prev === false || $tokens[$prev]['code'] !== T_FINAL) { return; } $next = ++$token['scope_opener']; $end = --$token['scope_closer']; for (; $next <= $end; ++$next) { if ($tokens[$next]['code'] === T_FINAL) { $error = 'Unnecessary FINAL modifier in FINAL class'; $phpcsFile->addWarning($error, $next, 'Found'); } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/CodeAnalysis/UnusedFunctionParameterSniff.php0000644000076500000240000002130213614652361032517 0ustar gsherwoodstaff * @author Greg Sherwood * @copyright 2007-2014 Manuel Pichler. All rights reserved. * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\CodeAnalysis; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class UnusedFunctionParameterSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_FUNCTION, T_CLOSURE, T_FN, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $token = $tokens[$stackPtr]; // Skip broken function declarations. if (isset($token['scope_opener']) === false || isset($token['parenthesis_opener']) === false) { return; } $errorCode = 'Found'; $implements = false; $extends = false; $classPtr = $phpcsFile->getCondition($stackPtr, T_CLASS); if ($classPtr !== false) { $implements = $phpcsFile->findImplementedInterfaceNames($classPtr); $extends = $phpcsFile->findExtendedClassName($classPtr); if ($extends !== false) { $errorCode .= 'InExtendedClass'; } else if ($implements !== false) { $errorCode .= 'InImplementedInterface'; } } $params = []; $methodParams = $phpcsFile->getMethodParameters($stackPtr); // Skip when no parameters found. $methodParamsCount = count($methodParams); if ($methodParamsCount === 0) { return; } foreach ($methodParams as $param) { $params[$param['name']] = $stackPtr; } $next = ++$token['scope_opener']; $end = --$token['scope_closer']; $foundContent = false; $validTokens = [ T_HEREDOC => T_HEREDOC, T_NOWDOC => T_NOWDOC, T_END_HEREDOC => T_END_HEREDOC, T_END_NOWDOC => T_END_NOWDOC, T_DOUBLE_QUOTED_STRING => T_DOUBLE_QUOTED_STRING, ]; $validTokens += Tokens::$emptyTokens; for (; $next <= $end; ++$next) { $token = $tokens[$next]; $code = $token['code']; // Ignorable tokens. if (isset(Tokens::$emptyTokens[$code]) === true) { continue; } if ($foundContent === false) { // A throw statement as the first content indicates an interface method. if ($code === T_THROW && $implements !== false) { return; } // A return statement as the first content indicates an interface method. if ($code === T_RETURN) { $tmp = $phpcsFile->findNext(Tokens::$emptyTokens, ($next + 1), null, true); if ($tmp === false && $implements !== false) { return; } // There is a return. if ($tokens[$tmp]['code'] === T_SEMICOLON && $implements !== false) { return; } $tmp = $phpcsFile->findNext(Tokens::$emptyTokens, ($tmp + 1), null, true); if ($tmp !== false && $tokens[$tmp]['code'] === T_SEMICOLON && $implements !== false) { // There is a return . return; } }//end if }//end if $foundContent = true; if ($code === T_VARIABLE && isset($params[$token['content']]) === true) { unset($params[$token['content']]); } else if ($code === T_DOLLAR) { $nextToken = $phpcsFile->findNext(T_WHITESPACE, ($next + 1), null, true); if ($tokens[$nextToken]['code'] === T_OPEN_CURLY_BRACKET) { $nextToken = $phpcsFile->findNext(T_WHITESPACE, ($nextToken + 1), null, true); if ($tokens[$nextToken]['code'] === T_STRING) { $varContent = '$'.$tokens[$nextToken]['content']; if (isset($params[$varContent]) === true) { unset($params[$varContent]); } } } } else if ($code === T_DOUBLE_QUOTED_STRING || $code === T_START_HEREDOC || $code === T_START_NOWDOC ) { // Tokenize strings that can contain variables. // Make sure the string is re-joined if it occurs over multiple lines. $content = $token['content']; for ($i = ($next + 1); $i <= $end; $i++) { if (isset($validTokens[$tokens[$i]['code']]) === true) { $content .= $tokens[$i]['content']; $next++; } else { break; } } $stringTokens = token_get_all(sprintf('', $content)); foreach ($stringTokens as $stringPtr => $stringToken) { if (is_array($stringToken) === false) { continue; } $varContent = ''; if ($stringToken[0] === T_DOLLAR_OPEN_CURLY_BRACES) { $varContent = '$'.$stringTokens[($stringPtr + 1)][1]; } else if ($stringToken[0] === T_VARIABLE) { $varContent = $stringToken[1]; } if ($varContent !== '' && isset($params[$varContent]) === true) { unset($params[$varContent]); } } }//end if }//end for if ($foundContent === true && count($params) > 0) { $error = 'The method parameter %s is never used'; // If there is only one parameter and it is unused, no need for additional errorcode toggling logic. if ($methodParamsCount === 1) { foreach ($params as $paramName => $position) { $data = [$paramName]; $phpcsFile->addWarning($error, $position, $errorCode, $data); } return; } $foundLastUsed = false; $lastIndex = ($methodParamsCount - 1); $errorInfo = []; for ($i = $lastIndex; $i >= 0; --$i) { if ($foundLastUsed !== false) { if (isset($params[$methodParams[$i]['name']]) === true) { $errorInfo[$methodParams[$i]['name']] = [ 'position' => $params[$methodParams[$i]['name']], 'errorcode' => $errorCode.'BeforeLastUsed', ]; } } else { if (isset($params[$methodParams[$i]['name']]) === false) { $foundLastUsed = true; } else { $errorInfo[$methodParams[$i]['name']] = [ 'position' => $params[$methodParams[$i]['name']], 'errorcode' => $errorCode.'AfterLastUsed', ]; } } } if (count($errorInfo) > 0) { $errorInfo = array_reverse($errorInfo); foreach ($errorInfo as $paramName => $info) { $data = [$paramName]; $phpcsFile->addWarning($error, $info['position'], $info['errorcode'], $data); } } }//end if }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/CodeAnalysis/UselessOverridingMethodSniff.php0000644000076500000240000001164613614652361032534 0ustar gsherwoodstaff * class FooBar { * public function __construct($a, $b) { * parent::__construct($a, $b); * } * } * * * @author Manuel Pichler * @copyright 2007-2014 Manuel Pichler. All rights reserved. * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\CodeAnalysis; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class UselessOverridingMethodSniff implements Sniff { /** * Registers the tokens that this sniff wants to listen for. * * @return int[] */ public function register() { return [T_FUNCTION]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $token = $tokens[$stackPtr]; // Skip function without body. if (isset($token['scope_opener']) === false) { return; } // Get function name. $methodName = $phpcsFile->getDeclarationName($stackPtr); // Get all parameters from method signature. $signature = []; foreach ($phpcsFile->getMethodParameters($stackPtr) as $param) { $signature[] = $param['name']; } $next = ++$token['scope_opener']; $end = --$token['scope_closer']; for (; $next <= $end; ++$next) { $code = $tokens[$next]['code']; if (isset(Tokens::$emptyTokens[$code]) === true) { continue; } else if ($code === T_RETURN) { continue; } break; } // Any token except 'parent' indicates correct code. if ($tokens[$next]['code'] !== T_PARENT) { return; } // Find next non empty token index, should be double colon. $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($next + 1), null, true); // Skip for invalid code. if ($next === false || $tokens[$next]['code'] !== T_DOUBLE_COLON) { return; } // Find next non empty token index, should be the function name. $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($next + 1), null, true); // Skip for invalid code or other method. if ($next === false || $tokens[$next]['content'] !== $methodName) { return; } // Find next non empty token index, should be the open parenthesis. $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($next + 1), null, true); // Skip for invalid code. if ($next === false || $tokens[$next]['code'] !== T_OPEN_PARENTHESIS) { return; } $parameters = ['']; $parenthesisCount = 1; $count = count($tokens); for (++$next; $next < $count; ++$next) { $code = $tokens[$next]['code']; if ($code === T_OPEN_PARENTHESIS) { ++$parenthesisCount; } else if ($code === T_CLOSE_PARENTHESIS) { --$parenthesisCount; } else if ($parenthesisCount === 1 && $code === T_COMMA) { $parameters[] = ''; } else if (isset(Tokens::$emptyTokens[$code]) === false) { $parameters[(count($parameters) - 1)] .= $tokens[$next]['content']; } if ($parenthesisCount === 0) { break; } }//end for $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($next + 1), null, true); if ($next === false || $tokens[$next]['code'] !== T_SEMICOLON) { return; } // Check rest of the scope. for (++$next; $next <= $end; ++$next) { $code = $tokens[$next]['code']; // Skip for any other content. if (isset(Tokens::$emptyTokens[$code]) === false) { return; } } $parameters = array_map('trim', $parameters); $parameters = array_filter($parameters); if (count($parameters) === count($signature) && $parameters === $signature) { $phpcsFile->addWarning('Possible useless method overriding detected', $stackPtr, 'Found'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Commenting/DocCommentSniff.php0000644000076500000240000003411413614652361027464 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Commenting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class DocCommentSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_DOC_COMMENT_OPEN_TAG]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['comment_closer']) === false || ($tokens[$tokens[$stackPtr]['comment_closer']]['content'] === '' && $tokens[$stackPtr]['comment_closer'] === ($phpcsFile->numTokens - 1)) ) { // Don't process an unfinished comment during live coding. return; } $commentStart = $stackPtr; $commentEnd = $tokens[$stackPtr]['comment_closer']; $empty = [ T_DOC_COMMENT_WHITESPACE, T_DOC_COMMENT_STAR, ]; $short = $phpcsFile->findNext($empty, ($stackPtr + 1), $commentEnd, true); if ($short === false) { // No content at all. $error = 'Doc comment is empty'; $phpcsFile->addError($error, $stackPtr, 'Empty'); return; } // The first line of the comment should just be the /** code. if ($tokens[$short]['line'] === $tokens[$stackPtr]['line']) { $error = 'The open comment tag must be the only content on the line'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'ContentAfterOpen'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->addNewline($stackPtr); $phpcsFile->fixer->addContentBefore($short, '* '); $phpcsFile->fixer->endChangeset(); } } // The last line of the comment should just be the */ code. $prev = $phpcsFile->findPrevious($empty, ($commentEnd - 1), $stackPtr, true); if ($tokens[$prev]['line'] === $tokens[$commentEnd]['line']) { $error = 'The close comment tag must be the only content on the line'; $fix = $phpcsFile->addFixableError($error, $commentEnd, 'ContentBeforeClose'); if ($fix === true) { $phpcsFile->fixer->addNewlineBefore($commentEnd); } } // Check for additional blank lines at the end of the comment. if ($tokens[$prev]['line'] < ($tokens[$commentEnd]['line'] - 1)) { $error = 'Additional blank lines found at end of doc comment'; $fix = $phpcsFile->addFixableError($error, $commentEnd, 'SpacingAfter'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($prev + 1); $i < $commentEnd; $i++) { if ($tokens[($i + 1)]['line'] === $tokens[$commentEnd]['line']) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } } // Check for a comment description. if ($tokens[$short]['code'] !== T_DOC_COMMENT_STRING) { $error = 'Missing short description in doc comment'; $phpcsFile->addError($error, $stackPtr, 'MissingShort'); } else { // No extra newline before short description. if ($tokens[$short]['line'] !== ($tokens[$stackPtr]['line'] + 1)) { $error = 'Doc comment short description must be on the first line'; $fix = $phpcsFile->addFixableError($error, $short, 'SpacingBeforeShort'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = $stackPtr; $i < $short; $i++) { if ($tokens[$i]['line'] === $tokens[$stackPtr]['line']) { continue; } else if ($tokens[$i]['line'] === $tokens[$short]['line']) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } } // Account for the fact that a short description might cover // multiple lines. $shortContent = $tokens[$short]['content']; $shortEnd = $short; for ($i = ($short + 1); $i < $commentEnd; $i++) { if ($tokens[$i]['code'] === T_DOC_COMMENT_STRING) { if ($tokens[$i]['line'] === ($tokens[$shortEnd]['line'] + 1)) { $shortContent .= $tokens[$i]['content']; $shortEnd = $i; } else { break; } } } if (preg_match('/^\p{Ll}/u', $shortContent) === 1) { $error = 'Doc comment short description must start with a capital letter'; $phpcsFile->addError($error, $short, 'ShortNotCapital'); } $long = $phpcsFile->findNext($empty, ($shortEnd + 1), ($commentEnd - 1), true); if ($long !== false && $tokens[$long]['code'] === T_DOC_COMMENT_STRING) { if ($tokens[$long]['line'] !== ($tokens[$shortEnd]['line'] + 2)) { $error = 'There must be exactly one blank line between descriptions in a doc comment'; $fix = $phpcsFile->addFixableError($error, $long, 'SpacingBetween'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($shortEnd + 1); $i < $long; $i++) { if ($tokens[$i]['line'] === $tokens[$shortEnd]['line']) { continue; } else if ($tokens[$i]['line'] === ($tokens[$long]['line'] - 1)) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } } if (preg_match('/^\p{Ll}/u', $tokens[$long]['content']) === 1) { $error = 'Doc comment long description must start with a capital letter'; $phpcsFile->addError($error, $long, 'LongNotCapital'); } }//end if }//end if if (empty($tokens[$commentStart]['comment_tags']) === true) { // No tags in the comment. return; } $firstTag = $tokens[$commentStart]['comment_tags'][0]; $prev = $phpcsFile->findPrevious($empty, ($firstTag - 1), $stackPtr, true); if ($tokens[$firstTag]['line'] !== ($tokens[$prev]['line'] + 2) && $tokens[$prev]['code'] !== T_DOC_COMMENT_OPEN_TAG ) { $error = 'There must be exactly one blank line before the tags in a doc comment'; $fix = $phpcsFile->addFixableError($error, $firstTag, 'SpacingBeforeTags'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($prev + 1); $i < $firstTag; $i++) { if ($tokens[$i]['line'] === $tokens[$firstTag]['line']) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $indent = str_repeat(' ', $tokens[$stackPtr]['column']); $phpcsFile->fixer->addContent($prev, $phpcsFile->eolChar.$indent.'*'.$phpcsFile->eolChar); $phpcsFile->fixer->endChangeset(); } } // Break out the tags into groups and check alignment within each. // A tag group is one where there are no blank lines between tags. // The param tag group is special as it requires all @param tags to be inside. $tagGroups = []; $groupid = 0; $paramGroupid = null; foreach ($tokens[$commentStart]['comment_tags'] as $pos => $tag) { if ($pos > 0) { $prev = $phpcsFile->findPrevious( T_DOC_COMMENT_STRING, ($tag - 1), $tokens[$commentStart]['comment_tags'][($pos - 1)] ); if ($prev === false) { $prev = $tokens[$commentStart]['comment_tags'][($pos - 1)]; } if ($tokens[$prev]['line'] !== ($tokens[$tag]['line'] - 1)) { $groupid++; } } if ($tokens[$tag]['content'] === '@param') { if ($paramGroupid !== null && $paramGroupid !== $groupid ) { $error = 'Parameter tags must be grouped together in a doc comment'; $phpcsFile->addError($error, $tag, 'ParamGroup'); } if ($paramGroupid === null) { $paramGroupid = $groupid; } }//end if $tagGroups[$groupid][] = $tag; }//end foreach foreach ($tagGroups as $groupid => $group) { $maxLength = 0; $paddings = []; foreach ($group as $pos => $tag) { if ($paramGroupid === $groupid && $tokens[$tag]['content'] !== '@param' ) { $error = 'Tag %s cannot be grouped with parameter tags in a doc comment'; $data = [$tokens[$tag]['content']]; $phpcsFile->addError($error, $tag, 'NonParamGroup', $data); } $tagLength = $tokens[$tag]['length']; if ($tagLength > $maxLength) { $maxLength = $tagLength; } // Check for a value. No value means no padding needed. $string = $phpcsFile->findNext(T_DOC_COMMENT_STRING, $tag, $commentEnd); if ($string !== false && $tokens[$string]['line'] === $tokens[$tag]['line']) { $paddings[$tag] = $tokens[($tag + 1)]['length']; } } // Check that there was single blank line after the tag block // but account for a multi-line tag comments. $lastTag = $group[$pos]; $next = $phpcsFile->findNext(T_DOC_COMMENT_TAG, ($lastTag + 3), $commentEnd); if ($next !== false) { $prev = $phpcsFile->findPrevious([T_DOC_COMMENT_TAG, T_DOC_COMMENT_STRING], ($next - 1), $commentStart); if ($tokens[$next]['line'] !== ($tokens[$prev]['line'] + 2)) { $error = 'There must be a single blank line after a tag group'; $fix = $phpcsFile->addFixableError($error, $lastTag, 'SpacingAfterTagGroup'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($prev + 1); $i < $next; $i++) { if ($tokens[$i]['line'] === $tokens[$next]['line']) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $indent = str_repeat(' ', $tokens[$stackPtr]['column']); $phpcsFile->fixer->addContent($prev, $phpcsFile->eolChar.$indent.'*'.$phpcsFile->eolChar); $phpcsFile->fixer->endChangeset(); } } }//end if // Now check paddings. foreach ($paddings as $tag => $padding) { $required = ($maxLength - $tokens[$tag]['length'] + 1); if ($padding !== $required) { $error = 'Tag value for %s tag indented incorrectly; expected %s spaces but found %s'; $data = [ $tokens[$tag]['content'], $required, $padding, ]; $fix = $phpcsFile->addFixableError($error, ($tag + 1), 'TagValueIndent', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($tag + 1), str_repeat(' ', $required)); } } } }//end foreach // If there is a param group, it needs to be first. if ($paramGroupid !== null && $paramGroupid !== 0) { $error = 'Parameter tags must be defined first in a doc comment'; $phpcsFile->addError($error, $tagGroups[$paramGroupid][0], 'ParamNotFirst'); } $foundTags = []; foreach ($tokens[$stackPtr]['comment_tags'] as $pos => $tag) { $tagName = $tokens[$tag]['content']; if (isset($foundTags[$tagName]) === true) { $lastTag = $tokens[$stackPtr]['comment_tags'][($pos - 1)]; if ($tokens[$lastTag]['content'] !== $tagName) { $error = 'Tags must be grouped together in a doc comment'; $phpcsFile->addError($error, $tag, 'TagsNotGrouped'); } continue; } $foundTags[$tagName] = true; } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Commenting/FixmeSniff.php0000644000076500000240000000432013614652361026500 0ustar gsherwoodstaff * @author Sam Graham * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Commenting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class FixmeSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return array_diff(Tokens::$commentTokens, Tokens::$phpcsCommentTokens); }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $content = $tokens[$stackPtr]['content']; $matches = []; preg_match('/(?:\A|[^\p{L}]+)fixme([^\p{L}]+(.*)|\Z)/ui', $content, $matches); if (empty($matches) === false) { // Clear whitespace and some common characters not required at // the end of a fixme message to make the error more informative. $type = 'CommentFound'; $fixmeMessage = trim($matches[1]); $fixmeMessage = trim($fixmeMessage, '-:[](). '); $error = 'Comment refers to a FIXME task'; $data = [$fixmeMessage]; if ($fixmeMessage !== '') { $type = 'TaskFound'; $error .= ' "%s"'; } $phpcsFile->addError($error, $stackPtr, $type, $data); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Commenting/TodoSniff.php0000644000076500000240000000421613614652361026341 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Commenting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class TodoSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return array_diff(Tokens::$commentTokens, Tokens::$phpcsCommentTokens); }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $content = $tokens[$stackPtr]['content']; $matches = []; preg_match('/(?:\A|[^\p{L}]+)todo([^\p{L}]+(.*)|\Z)/ui', $content, $matches); if (empty($matches) === false) { // Clear whitespace and some common characters not required at // the end of a to-do message to make the warning more informative. $type = 'CommentFound'; $todoMessage = trim($matches[1]); $todoMessage = trim($todoMessage, '-:[](). '); $error = 'Comment refers to a TODO task'; $data = [$todoMessage]; if ($todoMessage !== '') { $type = 'TaskFound'; $error .= ' "%s"'; } $phpcsFile->addWarning($error, $stackPtr, $type, $data); } }//end process() }//end class ././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/ControlStructures/DisallowYodaConditionsSniff.phpPHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/ControlStructures/DisallowYodaConditionsSniff.php0000644000076500000240000001400213614652361033477 0ustar gsherwoodstaff * @author Mark Scherer * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\ControlStructures; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class DisallowYodaConditionsSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return Tokens::$comparisonTokens; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $previousIndex = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); $relevantTokens = [ T_CLOSE_SHORT_ARRAY, T_CLOSE_PARENTHESIS, T_TRUE, T_FALSE, T_NULL, T_LNUMBER, T_DNUMBER, T_CONSTANT_ENCAPSED_STRING, ]; if ($previousIndex === false || in_array($tokens[$previousIndex]['code'], $relevantTokens, true) === false ) { return; } if ($tokens[$previousIndex]['code'] === T_CLOSE_SHORT_ARRAY) { $previousIndex = $tokens[$previousIndex]['bracket_opener']; if ($this->isArrayStatic($phpcsFile, $previousIndex) === false) { return; } } $prevIndex = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($previousIndex - 1), null, true); if ($prevIndex === false) { return; } if (in_array($tokens[$prevIndex]['code'], Tokens::$arithmeticTokens, true) === true) { return; } if ($tokens[$prevIndex]['code'] === T_STRING_CONCAT) { return; } // Is it a parenthesis. if ($tokens[$previousIndex]['code'] === T_CLOSE_PARENTHESIS) { // Check what exists inside the parenthesis. $closeParenthesisIndex = $phpcsFile->findPrevious( Tokens::$emptyTokens, ($tokens[$previousIndex]['parenthesis_opener'] - 1), null, true ); if ($closeParenthesisIndex === false || $tokens[$closeParenthesisIndex]['code'] !== T_ARRAY) { if ($tokens[$closeParenthesisIndex]['code'] === T_STRING) { return; } // If it is not an array check what is inside. $found = $phpcsFile->findPrevious( T_VARIABLE, ($previousIndex - 1), $tokens[$previousIndex]['parenthesis_opener'] ); // If a variable exists, it is not Yoda. if ($found !== false) { return; } // If there is nothing inside the parenthesis, it it not a Yoda. $opener = $tokens[$previousIndex]['parenthesis_opener']; $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($previousIndex - 1), ($opener + 1), true); if ($prev === false) { return; } } else if ($tokens[$closeParenthesisIndex]['code'] === T_ARRAY && $this->isArrayStatic($phpcsFile, $closeParenthesisIndex) === false ) { return; }//end if }//end if $phpcsFile->addError( 'Usage of Yoda conditions is not allowed; switch the expression order', $stackPtr, 'Found' ); }//end process() /** * Determines if an array is a static definition. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $arrayToken The position of the array token. * * @return bool */ public function isArrayStatic(File $phpcsFile, $arrayToken) { $tokens = $phpcsFile->getTokens(); $arrayEnd = null; if ($tokens[$arrayToken]['code'] === T_OPEN_SHORT_ARRAY) { $start = $arrayToken; $end = $tokens[$arrayToken]['bracket_closer']; } else if ($tokens[$arrayToken]['code'] === T_ARRAY) { $start = $tokens[$arrayToken]['parenthesis_opener']; $end = $tokens[$arrayToken]['parenthesis_closer']; } else { return true; } $staticTokens = Tokens::$emptyTokens; $staticTokens += Tokens::$textStringTokens; $staticTokens += Tokens::$assignmentTokens; $staticTokens += Tokens::$equalityTokens; $staticTokens += Tokens::$comparisonTokens; $staticTokens += Tokens::$arithmeticTokens; $staticTokens += Tokens::$operators; $staticTokens += Tokens::$booleanOperators; $staticTokens += Tokens::$castTokens; $staticTokens += Tokens::$bracketTokens; $staticTokens += [ T_DOUBLE_ARROW => T_DOUBLE_ARROW, T_COMMA => T_COMMA, T_TRUE => T_TRUE, T_FALSE => T_FALSE, ]; for ($i = ($start + 1); $i < $end; $i++) { if (isset($tokens[$i]['scope_closer']) === true) { $i = $tokens[$i]['scope_closer']; continue; } if (isset($staticTokens[$tokens[$i]['code']]) === false) { return false; } } return true; }//end isArrayStatic() }//end class ././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/ControlStructures/InlineControlStructureSniff.phpPHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/ControlStructures/InlineControlStructureSniff.php0000644000076500000240000003312313614652361033557 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\ControlStructures; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class InlineControlStructureSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * If true, an error will be thrown; otherwise a warning. * * @var boolean */ public $error = true; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_IF, T_ELSE, T_ELSEIF, T_FOREACH, T_WHILE, T_DO, T_SWITCH, T_FOR, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['scope_opener']) === true) { $phpcsFile->recordMetric($stackPtr, 'Control structure defined inline', 'no'); return; } // Ignore the ELSE in ELSE IF. We'll process the IF part later. if ($tokens[$stackPtr]['code'] === T_ELSE) { $next = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($tokens[$next]['code'] === T_IF) { return; } } if ($tokens[$stackPtr]['code'] === T_WHILE || $tokens[$stackPtr]['code'] === T_FOR) { // This could be from a DO WHILE, which doesn't have an opening brace or a while/for without body. if (isset($tokens[$stackPtr]['parenthesis_closer']) === true) { $afterParensCloser = $phpcsFile->findNext(Tokens::$emptyTokens, ($tokens[$stackPtr]['parenthesis_closer'] + 1), null, true); if ($afterParensCloser === false) { // Live coding. return; } if ($tokens[$afterParensCloser]['code'] === T_SEMICOLON) { $phpcsFile->recordMetric($stackPtr, 'Control structure defined inline', 'no'); return; } } // In Javascript DO WHILE loops without curly braces are legal. This // is only valid if a single statement is present between the DO and // the WHILE. We can detect this by checking only a single semicolon // is present between them. if ($tokens[$stackPtr]['code'] === T_WHILE && $phpcsFile->tokenizerType === 'JS') { $lastDo = $phpcsFile->findPrevious(T_DO, ($stackPtr - 1)); $lastSemicolon = $phpcsFile->findPrevious(T_SEMICOLON, ($stackPtr - 1)); if ($lastDo !== false && $lastSemicolon !== false && $lastDo < $lastSemicolon) { $precedingSemicolon = $phpcsFile->findPrevious(T_SEMICOLON, ($lastSemicolon - 1)); if ($precedingSemicolon === false || $precedingSemicolon < $lastDo) { return; } } } }//end if if (isset($tokens[$stackPtr]['parenthesis_opener'], $tokens[$stackPtr]['parenthesis_closer']) === false && $tokens[$stackPtr]['code'] !== T_ELSE ) { if ($tokens[$stackPtr]['code'] !== T_DO) { // Live coding or parse error. return; } $nextWhile = $phpcsFile->findNext(T_WHILE, ($stackPtr + 1)); if ($nextWhile !== false && isset($tokens[$nextWhile]['parenthesis_opener'], $tokens[$nextWhile]['parenthesis_closer']) === false ) { // Live coding or parse error. return; } unset($nextWhile); } $start = $stackPtr; if (isset($tokens[$stackPtr]['parenthesis_closer']) === true) { $start = $tokens[$stackPtr]['parenthesis_closer']; } $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($start + 1), null, true); if ($nextNonEmpty === false) { // Live coding or parse error. return; } if ($tokens[$nextNonEmpty]['code'] === T_COLON) { // Alternative control structure. // T_END... missing. Either live coding, parse error or end // tag in short open tags and scan run with short_open_tag=Off. // Bow out completely as any further detection will be unreliable // and create incorrect fixes or cause fixer conflicts. return ($phpcsFile->numTokens + 1); } unset($nextNonEmpty, $start); // This is a control structure without an opening brace, // so it is an inline statement. if ($this->error === true) { $fix = $phpcsFile->addFixableError('Inline control structures are not allowed', $stackPtr, 'NotAllowed'); } else { $fix = $phpcsFile->addFixableWarning('Inline control structures are discouraged', $stackPtr, 'Discouraged'); } $phpcsFile->recordMetric($stackPtr, 'Control structure defined inline', 'yes'); // Stop here if we are not fixing the error. if ($fix !== true) { return; } $phpcsFile->fixer->beginChangeset(); if (isset($tokens[$stackPtr]['parenthesis_closer']) === true) { $closer = $tokens[$stackPtr]['parenthesis_closer']; } else { $closer = $stackPtr; } if ($tokens[($closer + 1)]['code'] === T_WHITESPACE || $tokens[($closer + 1)]['code'] === T_SEMICOLON ) { $phpcsFile->fixer->addContent($closer, ' {'); } else { $phpcsFile->fixer->addContent($closer, ' { '); } $fixableScopeOpeners = $this->register(); $lastNonEmpty = $closer; for ($end = ($closer + 1); $end < $phpcsFile->numTokens; $end++) { if ($tokens[$end]['code'] === T_SEMICOLON) { break; } if ($tokens[$end]['code'] === T_CLOSE_TAG) { $end = $lastNonEmpty; break; } if (in_array($tokens[$end]['code'], $fixableScopeOpeners, true) === true && isset($tokens[$end]['scope_opener']) === false ) { // The best way to fix nested inline scopes is middle-out. // So skip this one. It will be detected and fixed on a future loop. $phpcsFile->fixer->rollbackChangeset(); return; } if (isset($tokens[$end]['scope_opener']) === true) { $type = $tokens[$end]['code']; $end = $tokens[$end]['scope_closer']; if ($type === T_DO || $type === T_IF || $type === T_ELSEIF || $type === T_TRY) { $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($end + 1), null, true); if ($next === false) { break; } $nextType = $tokens[$next]['code']; // Let additional conditions loop and find their ending. if (($type === T_IF || $type === T_ELSEIF) && ($nextType === T_ELSEIF || $nextType === T_ELSE) ) { continue; } // Account for DO... WHILE conditions. if ($type === T_DO && $nextType === T_WHILE) { $end = $phpcsFile->findNext(T_SEMICOLON, ($next + 1)); } // Account for TRY... CATCH statements. if ($type === T_TRY && $nextType === T_CATCH) { $end = $tokens[$next]['scope_closer']; } } else if ($type === T_CLOSURE) { // There should be a semicolon after the closing brace. $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($end + 1), null, true); if ($next !== false && $tokens[$next]['code'] === T_SEMICOLON) { $end = $next; } }//end if if ($tokens[$end]['code'] !== T_END_HEREDOC && $tokens[$end]['code'] !== T_END_NOWDOC ) { break; } }//end if if (isset($tokens[$end]['parenthesis_closer']) === true) { $end = $tokens[$end]['parenthesis_closer']; $lastNonEmpty = $end; continue; } if ($tokens[$end]['code'] !== T_WHITESPACE) { $lastNonEmpty = $end; } }//end for if ($end === $phpcsFile->numTokens) { $end = $lastNonEmpty; } $nextContent = $phpcsFile->findNext(Tokens::$emptyTokens, ($end + 1), null, true); if ($nextContent === false || $tokens[$nextContent]['line'] !== $tokens[$end]['line']) { // Looks for completely empty statements. $next = $phpcsFile->findNext(T_WHITESPACE, ($closer + 1), ($end + 1), true); } else { $next = ($end + 1); $endLine = $end; } if ($next !== $end) { if ($nextContent === false || $tokens[$nextContent]['line'] !== $tokens[$end]['line']) { // Account for a comment on the end of the line. for ($endLine = $end; $endLine < $phpcsFile->numTokens; $endLine++) { if (isset($tokens[($endLine + 1)]) === false || $tokens[$endLine]['line'] !== $tokens[($endLine + 1)]['line'] ) { break; } } if (isset(Tokens::$commentTokens[$tokens[$endLine]['code']]) === false && ($tokens[$endLine]['code'] !== T_WHITESPACE || isset(Tokens::$commentTokens[$tokens[($endLine - 1)]['code']]) === false) ) { $endLine = $end; } } if ($endLine !== $end) { $endToken = $endLine; $addedContent = ''; } else { $endToken = $end; $addedContent = $phpcsFile->eolChar; if ($tokens[$end]['code'] !== T_SEMICOLON && $tokens[$end]['code'] !== T_CLOSE_CURLY_BRACKET ) { $phpcsFile->fixer->addContent($end, '; '); } } $next = $phpcsFile->findNext(T_WHITESPACE, ($endToken + 1), null, true); if ($next !== false && ($tokens[$next]['code'] === T_ELSE || $tokens[$next]['code'] === T_ELSEIF) ) { $phpcsFile->fixer->addContentBefore($next, '} '); } else { $indent = ''; for ($first = $stackPtr; $first > 0; $first--) { if ($tokens[$first]['column'] === 1) { break; } } if ($tokens[$first]['code'] === T_WHITESPACE) { $indent = $tokens[$first]['content']; } else if ($tokens[$first]['code'] === T_INLINE_HTML || $tokens[$first]['code'] === T_OPEN_TAG ) { $addedContent = ''; } $addedContent .= $indent.'}'; if ($next !== false && $tokens[$endToken]['code'] === T_COMMENT) { $addedContent .= $phpcsFile->eolChar; } $phpcsFile->fixer->addContent($endToken, $addedContent); }//end if } else { if ($nextContent === false || $tokens[$nextContent]['line'] !== $tokens[$end]['line']) { // Account for a comment on the end of the line. for ($endLine = $end; $endLine < $phpcsFile->numTokens; $endLine++) { if (isset($tokens[($endLine + 1)]) === false || $tokens[$endLine]['line'] !== $tokens[($endLine + 1)]['line'] ) { break; } } if ($tokens[$endLine]['code'] !== T_COMMENT && ($tokens[$endLine]['code'] !== T_WHITESPACE || $tokens[($endLine - 1)]['code'] !== T_COMMENT) ) { $endLine = $end; } } if ($endLine !== $end) { $phpcsFile->fixer->replaceToken($end, ''); $phpcsFile->fixer->addNewlineBefore($endLine); $phpcsFile->fixer->addContent($endLine, '}'); } else { $phpcsFile->fixer->replaceToken($end, '}'); } }//end if $phpcsFile->fixer->endChangeset(); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Debug/ClosureLinterSniff.php0000644000076500000240000000601613614652361027154 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Debug; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class ClosureLinterSniff implements Sniff { /** * A list of error codes that should show errors. * * All other error codes will show warnings. * * @var integer */ public $errorCodes = []; /** * A list of error codes to ignore. * * @var integer */ public $ignoreCodes = []; /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['JS']; /** * Returns the token types that this sniff is interested in. * * @return int[] */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes the tokens that this sniff is interested in. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If jslint.js could not be run */ public function process(File $phpcsFile, $stackPtr) { $lintPath = Config::getExecutablePath('gjslint'); if ($lintPath === null) { return; } $fileName = $phpcsFile->getFilename(); $lintPath = escapeshellcmd($lintPath); $cmd = $lintPath.' --nosummary --notime --unix_mode '.escapeshellarg($fileName); exec($cmd, $output, $retval); if (is_array($output) === false) { return; } foreach ($output as $finding) { $matches = []; $numMatches = preg_match('/^(.*):([0-9]+):\(.*?([0-9]+)\)(.*)$/', $finding, $matches); if ($numMatches === 0) { continue; } // Skip error codes we are ignoring. $code = $matches[3]; if (in_array($code, $this->ignoreCodes) === true) { continue; } $line = (int) $matches[2]; $error = trim($matches[4]); $message = 'gjslint says: (%s) %s'; $data = [ $code, $error, ]; if (in_array($code, $this->errorCodes) === true) { $phpcsFile->addErrorOnLine($message, $line, 'ExternalToolError', $data); } else { $phpcsFile->addWarningOnLine($message, $line, 'ExternalTool', $data); } }//end foreach // Ignore the rest of the file. return ($phpcsFile->numTokens + 1); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Debug/CSSLintSniff.php0000644000076500000240000000460213614652361025640 0ustar gsherwoodstaff * @copyright 2013-2014 Roman Levishchenko * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Debug; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class CSSLintSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['CSS']; /** * Returns the token types that this sniff is interested in. * * @return int[] */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes the tokens that this sniff is interested in. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $csslintPath = Config::getExecutablePath('csslint'); if ($csslintPath === null) { return; } $fileName = $phpcsFile->getFilename(); $cmd = escapeshellcmd($csslintPath).' '.escapeshellarg($fileName).' 2>&1'; exec($cmd, $output, $retval); if (is_array($output) === false) { return; } $count = count($output); for ($i = 0; $i < $count; $i++) { $matches = []; $numMatches = preg_match( '/(error|warning) at line (\d+)/', $output[$i], $matches ); if ($numMatches === 0) { continue; } $line = (int) $matches[2]; $message = 'csslint says: '.$output[($i + 1)]; // First line is message with error line and error code. // Second is error message. // Third is wrong line in file. // Fourth is empty line. $i += 4; $phpcsFile->addWarningOnLine($message, $line, 'ExternalTool'); }//end for // Ignore the rest of the file. return ($phpcsFile->numTokens + 1); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Debug/ESLintSniff.php0000644000076500000240000000622213614652361025517 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Debug; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class ESLintSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['JS']; /** * ESLint configuration file path. * * @var string|null Path to eslintrc. Null to autodetect. */ public $configFile = null; /** * Returns the token types that this sniff is interested in. * * @return int[] */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes the tokens that this sniff is interested in. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If jshint.js could not be run */ public function process(File $phpcsFile, $stackPtr) { $eslintPath = Config::getExecutablePath('eslint'); if ($eslintPath === null) { return; } $filename = $phpcsFile->getFilename(); $configFile = $this->configFile; if (empty($configFile) === true) { // Attempt to autodetect. $candidates = glob('.eslintrc{.js,.yaml,.yml,.json}', GLOB_BRACE); if (empty($candidates) === false) { $configFile = $candidates[0]; } } $eslintOptions = ['--format json']; if (empty($configFile) === false) { $eslintOptions[] = '--config '.escapeshellarg($configFile); } $cmd = escapeshellcmd(escapeshellarg($eslintPath).' '.implode(' ', $eslintOptions).' '.escapeshellarg($filename)); // Execute! exec($cmd, $stdout, $code); if ($code <= 0) { // No errors, continue. return ($phpcsFile->numTokens + 1); } $data = json_decode(implode("\n", $stdout)); if (json_last_error() !== JSON_ERROR_NONE) { // Ignore any errors. return ($phpcsFile->numTokens + 1); } // Data is a list of files, but we only pass a single one. $messages = $data[0]->messages; foreach ($messages as $error) { $message = 'eslint says: '.$error->message; if (empty($error->fatal) === false || $error->severity === 2) { $phpcsFile->addErrorOnLine($message, $error->line, 'ExternalTool'); } else { $phpcsFile->addWarningOnLine($message, $error->line, 'ExternalTool'); } } // Ignore the rest of the file. return ($phpcsFile->numTokens + 1); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Debug/JSHintSniff.php0000644000076500000240000000532613614652361025524 0ustar gsherwoodstaff * @author Alexander Wei§ * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Debug; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class JSHintSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['JS']; /** * Returns the token types that this sniff is interested in. * * @return int[] */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes the tokens that this sniff is interested in. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If jshint.js could not be run */ public function process(File $phpcsFile, $stackPtr) { $rhinoPath = Config::getExecutablePath('rhino'); $jshintPath = Config::getExecutablePath('jshint'); if ($rhinoPath === null && $jshintPath === null) { return; } $fileName = $phpcsFile->getFilename(); $jshintPath = escapeshellcmd($jshintPath); if ($rhinoPath !== null) { $rhinoPath = escapeshellcmd($rhinoPath); $cmd = "$rhinoPath \"$jshintPath\" ".escapeshellarg($fileName); exec($cmd, $output, $retval); $regex = '`^(?P.+)\(.+:(?P[0-9]+).*:[0-9]+\)$`'; } else { $cmd = "$jshintPath ".escapeshellarg($fileName); exec($cmd, $output, $retval); $regex = '`^(.+?): line (?P[0-9]+), col [0-9]+, (?P.+)$`'; } if (is_array($output) === true) { foreach ($output as $finding) { $matches = []; $numMatches = preg_match($regex, $finding, $matches); if ($numMatches === 0) { continue; } $line = (int) $matches['line']; $message = 'jshint says: '.trim($matches['error']); $phpcsFile->addWarningOnLine($message, $line, 'ExternalTool'); } } // Ignore the rest of the file. return ($phpcsFile->numTokens + 1); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Files/ByteOrderMarkSniff.php0000644000076500000240000000447413614652361027116 0ustar gsherwoodstaff * @author Greg Sherwood * @copyright 2010-2014 mediaSELF Sp. z o.o. * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Files; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class ByteOrderMarkSniff implements Sniff { /** * List of supported BOM definitions. * * Use encoding names as keys and hex BOM representations as values. * * @var array */ protected $bomDefinitions = [ 'UTF-8' => 'efbbbf', 'UTF-16 (BE)' => 'feff', 'UTF-16 (LE)' => 'fffe', ]; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_INLINE_HTML]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { // The BOM will be the very first token in the file. if ($stackPtr !== 0) { return; } $tokens = $phpcsFile->getTokens(); foreach ($this->bomDefinitions as $bomName => $expectedBomHex) { $bomByteLength = (strlen($expectedBomHex) / 2); $htmlBomHex = bin2hex(substr($tokens[$stackPtr]['content'], 0, $bomByteLength)); if ($htmlBomHex === $expectedBomHex) { $errorData = [$bomName]; $error = 'File contains %s byte order mark, which may corrupt your application'; $phpcsFile->addError($error, $stackPtr, 'Found', $errorData); $phpcsFile->recordMetric($stackPtr, 'Using byte order mark', 'yes'); return; } } $phpcsFile->recordMetric($stackPtr, 'Using byte order mark', 'no'); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Files/EndFileNewlineSniff.php0000644000076500000240000000423313614652361027225 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Files; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class EndFileNewlineSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', 'CSS', ]; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return int */ public function process(File $phpcsFile, $stackPtr) { // Skip to the end of the file. $tokens = $phpcsFile->getTokens(); $stackPtr = ($phpcsFile->numTokens - 1); if ($tokens[$stackPtr]['content'] === '') { $stackPtr--; } $eolCharLen = strlen($phpcsFile->eolChar); $lastChars = substr($tokens[$stackPtr]['content'], ($eolCharLen * -1)); if ($lastChars !== $phpcsFile->eolChar) { $phpcsFile->recordMetric($stackPtr, 'Newline at EOF', 'no'); $error = 'File must end with a newline character'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NotFound'); if ($fix === true) { $phpcsFile->fixer->addNewline($stackPtr); } } else { $phpcsFile->recordMetric($stackPtr, 'Newline at EOF', 'yes'); } // Ignore the rest of the file. return ($phpcsFile->numTokens + 1); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Files/EndFileNoNewlineSniff.php0000644000076500000240000000457013614652361027526 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Files; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class EndFileNoNewlineSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', 'CSS', ]; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return int */ public function process(File $phpcsFile, $stackPtr) { // Skip to the end of the file. $tokens = $phpcsFile->getTokens(); $stackPtr = ($phpcsFile->numTokens - 1); if ($tokens[$stackPtr]['content'] === '') { --$stackPtr; } $eolCharLen = strlen($phpcsFile->eolChar); $lastChars = substr($tokens[$stackPtr]['content'], ($eolCharLen * -1)); if ($lastChars === $phpcsFile->eolChar) { $error = 'File must not end with a newline character'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Found'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = $stackPtr; $i > 0; $i--) { $newContent = rtrim($tokens[$i]['content'], $phpcsFile->eolChar); $phpcsFile->fixer->replaceToken($i, $newContent); if ($newContent !== '') { break; } } $phpcsFile->fixer->endChangeset(); } } // Ignore the rest of the file. return ($phpcsFile->numTokens + 1); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Files/ExecutableFileSniff.php0000644000076500000240000000317413614652361027261 0ustar gsherwoodstaff * @copyright 2019 Matthew Peveler * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Files; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class ExecutableFileSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return int */ public function process(File $phpcsFile, $stackPtr) { $filename = $phpcsFile->getFilename(); if ($filename !== 'STDIN') { $perms = fileperms($phpcsFile->getFilename()); if (($perms & 0x0040) !== 0 || ($perms & 0x0008) !== 0 || ($perms & 0x0001) !== 0) { $error = 'A PHP file should not be executable; found file permissions set to %s'; $data = [substr(sprintf('%o', $perms), -4)]; $phpcsFile->addError($error, 0, 'Executable', $data); } } // Ignore the rest of the file. return ($phpcsFile->numTokens + 1); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Files/InlineHTMLSniff.php0000644000076500000240000000426013614652361026300 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Files; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class InlineHTMLSniff implements Sniff { /** * List of supported BOM definitions. * * Use encoding names as keys and hex BOM representations as values. * * @var array */ protected $bomDefinitions = [ 'UTF-8' => 'efbbbf', 'UTF-16 (BE)' => 'feff', 'UTF-16 (LE)' => 'fffe', ]; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_INLINE_HTML]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return int|null */ public function process(File $phpcsFile, $stackPtr) { // Allow a byte-order mark. $tokens = $phpcsFile->getTokens(); foreach ($this->bomDefinitions as $bomName => $expectedBomHex) { $bomByteLength = (strlen($expectedBomHex) / 2); $htmlBomHex = bin2hex(substr($tokens[0]['content'], 0, $bomByteLength)); if ($htmlBomHex === $expectedBomHex && strlen($tokens[0]['content']) === $bomByteLength) { return; } } // Ignore shebang lines. $tokens = $phpcsFile->getTokens(); if (substr($tokens[$stackPtr]['content'], 0, 2) === '#!') { return; } $error = 'PHP files must only contain PHP code'; $phpcsFile->addError($error, $stackPtr, 'Found'); return $phpcsFile->numTokens; }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Files/LineEndingsSniff.php0000644000076500000240000001004413614652361026571 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Files; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class LineEndingsSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', 'CSS', ]; /** * The valid EOL character. * * @var string */ public $eolChar = '\n'; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return int */ public function process(File $phpcsFile, $stackPtr) { $found = $phpcsFile->eolChar; $found = str_replace("\n", '\n', $found); $found = str_replace("\r", '\r', $found); $phpcsFile->recordMetric($stackPtr, 'EOL char', $found); if ($found === $this->eolChar) { // Ignore the rest of the file. return ($phpcsFile->numTokens + 1); } // Check for single line files without an EOL. This is a very special // case and the EOL char is set to \n when this happens. if ($found === '\n') { $tokens = $phpcsFile->getTokens(); $lastToken = ($phpcsFile->numTokens - 1); if ($tokens[$lastToken]['line'] === 1 && $tokens[$lastToken]['content'] !== "\n" ) { return; } } $error = 'End of line character is invalid; expected "%s" but found "%s"'; $expected = $this->eolChar; $expected = str_replace("\n", '\n', $expected); $expected = str_replace("\r", '\r', $expected); $data = [ $expected, $found, ]; // Errors are always reported on line 1, no matter where the first PHP tag is. $fix = $phpcsFile->addFixableError($error, 0, 'InvalidEOLChar', $data); if ($fix === true) { $tokens = $phpcsFile->getTokens(); switch ($this->eolChar) { case '\n': $eolChar = "\n"; break; case '\r': $eolChar = "\r"; break; case '\r\n': $eolChar = "\r\n"; break; default: $eolChar = $this->eolChar; break; } for ($i = 0; $i < $phpcsFile->numTokens; $i++) { if (isset($tokens[($i + 1)]) === false || $tokens[($i + 1)]['line'] > $tokens[$i]['line'] ) { // Token is the last on a line. if (isset($tokens[$i]['orig_content']) === true) { $tokenContent = $tokens[$i]['orig_content']; } else { $tokenContent = $tokens[$i]['content']; } if ($tokenContent === '') { // Special case for JS/CSS close tag. continue; } $newContent = rtrim($tokenContent, "\r\n"); $newContent .= $eolChar; $phpcsFile->fixer->replaceToken($i, $newContent); } }//end for }//end if // Ignore the rest of the file. return ($phpcsFile->numTokens + 1); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Files/LineLengthSniff.php0000644000076500000240000001461413614652361026432 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Files; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class LineLengthSniff implements Sniff { /** * The limit that the length of a line should not exceed. * * @var integer */ public $lineLimit = 80; /** * The limit that the length of a line must not exceed. * * Set to zero (0) to disable. * * @var integer */ public $absoluteLineLimit = 100; /** * Whether or not to ignore trailing comments. * * This has the effect of also ignoring all lines * that only contain comments. * * @var boolean */ public $ignoreComments = false; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return int */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); for ($i = 1; $i < $phpcsFile->numTokens; $i++) { if ($tokens[$i]['column'] === 1) { $this->checkLineLength($phpcsFile, $tokens, $i); } } $this->checkLineLength($phpcsFile, $tokens, $i); // Ignore the rest of the file. return ($phpcsFile->numTokens + 1); }//end process() /** * Checks if a line is too long. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param array $tokens The token stack. * @param int $stackPtr The first token on the next line. * * @return void */ protected function checkLineLength($phpcsFile, $tokens, $stackPtr) { // The passed token is the first on the line. $stackPtr--; if ($tokens[$stackPtr]['column'] === 1 && $tokens[$stackPtr]['length'] === 0 ) { // Blank line. return; } if ($tokens[$stackPtr]['column'] !== 1 && $tokens[$stackPtr]['content'] === $phpcsFile->eolChar ) { $stackPtr--; } $onlyComment = false; if (isset(Tokens::$commentTokens[$tokens[$stackPtr]['code']]) === true) { $prevNonWhiteSpace = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); if ($tokens[$stackPtr]['line'] !== $tokens[$prevNonWhiteSpace]['line']) { $onlyComment = true; } } if ($onlyComment === true && isset(Tokens::$phpcsCommentTokens[$tokens[$stackPtr]['code']]) === true ) { // Ignore PHPCS annotation comments that are on a line by themselves. return; } $lineLength = ($tokens[$stackPtr]['column'] + $tokens[$stackPtr]['length'] - 1); if ($this->ignoreComments === true && isset(Tokens::$commentTokens[$tokens[$stackPtr]['code']]) === true ) { // Trailing comments are being ignored in line length calculations. if ($onlyComment === true) { // The comment is the only thing on the line, so no need to check length. return; } $lineLength -= $tokens[$stackPtr]['length']; } // Record metrics for common line length groupings. if ($lineLength <= 80) { $phpcsFile->recordMetric($stackPtr, 'Line length', '80 or less'); } else if ($lineLength <= 120) { $phpcsFile->recordMetric($stackPtr, 'Line length', '81-120'); } else if ($lineLength <= 150) { $phpcsFile->recordMetric($stackPtr, 'Line length', '121-150'); } else { $phpcsFile->recordMetric($stackPtr, 'Line length', '151 or more'); } if ($onlyComment === true) { // If this is a long comment, check if it can be broken up onto multiple lines. // Some comments contain unbreakable strings like URLs and so it makes sense // to ignore the line length in these cases if the URL would be longer than the max // line length once you indent it to the correct level. if ($lineLength > $this->lineLimit) { $oldLength = strlen($tokens[$stackPtr]['content']); $newLength = strlen(ltrim($tokens[$stackPtr]['content'], "/#\t ")); $indent = (($tokens[$stackPtr]['column'] - 1) + ($oldLength - $newLength)); $nonBreakingLength = $tokens[$stackPtr]['length']; $space = strrpos($tokens[$stackPtr]['content'], ' '); if ($space !== false) { $nonBreakingLength -= ($space + 1); } if (($nonBreakingLength + $indent) > $this->lineLimit) { return; } } }//end if if ($this->absoluteLineLimit > 0 && $lineLength > $this->absoluteLineLimit ) { $data = [ $this->absoluteLineLimit, $lineLength, ]; $error = 'Line exceeds maximum limit of %s characters; contains %s characters'; $phpcsFile->addError($error, $stackPtr, 'MaxExceeded', $data); } else if ($lineLength > $this->lineLimit) { $data = [ $this->lineLimit, $lineLength, ]; $warning = 'Line exceeds %s characters; contains %s characters'; $phpcsFile->addWarning($warning, $stackPtr, 'TooLong', $data); } }//end checkLineLength() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Files/LowercasedFilenameSniff.php0000644000076500000240000000352513614652361030131 0ustar gsherwoodstaff * @copyright 2010-2014 Andy Grunwald * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Files; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class LowercasedFilenameSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return int */ public function process(File $phpcsFile, $stackPtr) { $filename = $phpcsFile->getFilename(); if ($filename === 'STDIN') { return; } $filename = basename($filename); $lowercaseFilename = strtolower($filename); if ($filename !== $lowercaseFilename) { $data = [ $filename, $lowercaseFilename, ]; $error = 'Filename "%s" doesn\'t match the expected filename "%s"'; $phpcsFile->addError($error, $stackPtr, 'NotFound', $data); $phpcsFile->recordMetric($stackPtr, 'Lowercase filename', 'no'); } else { $phpcsFile->recordMetric($stackPtr, 'Lowercase filename', 'yes'); } // Ignore the rest of the file. return ($phpcsFile->numTokens + 1); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Files/OneClassPerFileSniff.php0000644000076500000240000000250513614652361027353 0ustar gsherwoodstaff * @copyright 2010-2014 Andy Grunwald * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Files; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class OneClassPerFileSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_CLASS]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $nextClass = $phpcsFile->findNext($this->register(), ($stackPtr + 1)); if ($nextClass !== false) { $error = 'Only one class is allowed in a file'; $phpcsFile->addError($error, $nextClass, 'MultipleFound'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Files/OneInterfacePerFileSniff.php0000644000076500000240000000254113614652361030206 0ustar gsherwoodstaff * @copyright 2010-2014 Andy Grunwald * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Files; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class OneInterfacePerFileSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_INTERFACE]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $nextInterface = $phpcsFile->findNext($this->register(), ($stackPtr + 1)); if ($nextInterface !== false) { $error = 'Only one interface is allowed in a file'; $phpcsFile->addError($error, $nextInterface, 'MultipleFound'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Files/OneObjectStructurePerFileSniff.php0000644000076500000240000000267213614652361031442 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Files; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class OneObjectStructurePerFileSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_CLASS, T_INTERFACE, T_TRAIT, ]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $nextClass = $phpcsFile->findNext($this->register(), ($stackPtr + 1)); if ($nextClass !== false) { $error = 'Only one object structure is allowed in a file'; $phpcsFile->addError($error, $nextClass, 'MultipleFound'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Files/OneTraitPerFileSniff.php0000644000076500000240000000251513614652361027372 0ustar gsherwoodstaff * @copyright 2010-2014 Alexander Obuhovich * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Files; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class OneTraitPerFileSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_TRAIT]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $nextClass = $phpcsFile->findNext($this->register(), ($stackPtr + 1)); if ($nextClass !== false) { $error = 'Only one trait is allowed in a file'; $phpcsFile->addError($error, $nextClass, 'MultipleFound'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Formatting/DisallowMultipleStatementsSniff.php0000644000076500000240000000652613614652361033016 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Formatting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class DisallowMultipleStatementsSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_SEMICOLON]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $fixable = true; $prev = $stackPtr; do { $prev = $phpcsFile->findPrevious([T_SEMICOLON, T_OPEN_TAG, T_OPEN_TAG_WITH_ECHO, T_PHPCS_IGNORE], ($prev - 1)); if ($prev === false || $tokens[$prev]['code'] === T_OPEN_TAG || $tokens[$prev]['code'] === T_OPEN_TAG_WITH_ECHO ) { $phpcsFile->recordMetric($stackPtr, 'Multiple statements on same line', 'no'); return; } if ($tokens[$prev]['code'] === T_PHPCS_IGNORE) { $fixable = false; } } while ($tokens[$prev]['code'] === T_PHPCS_IGNORE); // Ignore multiple statements in a FOR condition. if (isset($tokens[$stackPtr]['nested_parenthesis']) === true) { foreach ($tokens[$stackPtr]['nested_parenthesis'] as $bracket) { if (isset($tokens[$bracket]['parenthesis_owner']) === false) { // Probably a closure sitting inside a function call. continue; } $owner = $tokens[$bracket]['parenthesis_owner']; if ($tokens[$owner]['code'] === T_FOR) { return; } } } if ($tokens[$prev]['line'] === $tokens[$stackPtr]['line']) { $phpcsFile->recordMetric($stackPtr, 'Multiple statements on same line', 'yes'); $error = 'Each PHP statement must be on a line by itself'; $code = 'SameLine'; if ($fixable === false) { $phpcsFile->addError($error, $stackPtr, $code); return; } $fix = $phpcsFile->addFixableError($error, $stackPtr, $code); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->addNewline($prev); if ($tokens[($prev + 1)]['code'] === T_WHITESPACE) { $phpcsFile->fixer->replaceToken(($prev + 1), ''); } $phpcsFile->fixer->endChangeset(); } } else { $phpcsFile->recordMetric($stackPtr, 'Multiple statements on same line', 'no'); }//end if }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Formatting/MultipleStatementAlignmentSniff.php0000644000076500000240000003556113614652361032774 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Formatting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class MultipleStatementAlignmentSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * If true, an error will be thrown; otherwise a warning. * * @var boolean */ public $error = false; /** * The maximum amount of padding before the alignment is ignored. * * If the amount of padding required to align this assignment with the * surrounding assignments exceeds this number, the assignment will be * ignored and no errors or warnings will be thrown. * * @var integer */ public $maxPadding = 1000; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { $tokens = Tokens::$assignmentTokens; unset($tokens[T_DOUBLE_ARROW]); return $tokens; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return int */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Ignore assignments used in a condition, like an IF or FOR. if (isset($tokens[$stackPtr]['nested_parenthesis']) === true) { // If the parenthesis is on the same line as the assignment, // then it should be ignored as it is specifically being grouped. $parens = $tokens[$stackPtr]['nested_parenthesis']; $lastParen = array_pop($parens); if ($tokens[$lastParen]['line'] === $tokens[$stackPtr]['line']) { return; } foreach ($tokens[$stackPtr]['nested_parenthesis'] as $start => $end) { if (isset($tokens[$start]['parenthesis_owner']) === true) { return; } } } $lastAssign = $this->checkAlignment($phpcsFile, $stackPtr); return ($lastAssign + 1); }//end process() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param int $end The token where checking should end. * If NULL, the entire file will be checked. * * @return int */ public function checkAlignment($phpcsFile, $stackPtr, $end=null) { $tokens = $phpcsFile->getTokens(); $assignments = []; $prevAssign = null; $lastLine = $tokens[$stackPtr]['line']; $maxPadding = null; $stopped = null; $lastCode = $stackPtr; $lastSemi = null; $arrayEnd = null; if ($end === null) { $end = $phpcsFile->numTokens; } $find = Tokens::$assignmentTokens; unset($find[T_DOUBLE_ARROW]); $scopes = Tokens::$scopeOpeners; unset($scopes[T_CLOSURE]); unset($scopes[T_ANON_CLASS]); unset($scopes[T_OBJECT]); for ($assign = $stackPtr; $assign < $end; $assign++) { if ($tokens[$assign]['level'] < $tokens[$stackPtr]['level']) { // Statement is in a different context, so the block is over. break; } if (isset($scopes[$tokens[$assign]['code']]) === true && isset($tokens[$assign]['scope_opener']) === true && $tokens[$assign]['level'] === $tokens[$stackPtr]['level'] ) { break; } if ($assign === $arrayEnd) { $arrayEnd = null; } if (isset($find[$tokens[$assign]['code']]) === false) { // A blank line indicates that the assignment block has ended. if (isset(Tokens::$emptyTokens[$tokens[$assign]['code']]) === false && ($tokens[$assign]['line'] - $tokens[$lastCode]['line']) > 1 && $tokens[$assign]['level'] === $tokens[$stackPtr]['level'] && $arrayEnd === null ) { break; } if ($tokens[$assign]['code'] === T_CLOSE_TAG) { // Breaking out of PHP ends the assignment block. break; } if ($tokens[$assign]['code'] === T_OPEN_SHORT_ARRAY && isset($tokens[$assign]['bracket_closer']) === true ) { $arrayEnd = $tokens[$assign]['bracket_closer']; } if ($tokens[$assign]['code'] === T_ARRAY && isset($tokens[$assign]['parenthesis_opener']) === true && isset($tokens[$tokens[$assign]['parenthesis_opener']]['parenthesis_closer']) === true ) { $arrayEnd = $tokens[$tokens[$assign]['parenthesis_opener']]['parenthesis_closer']; } if (isset(Tokens::$emptyTokens[$tokens[$assign]['code']]) === false) { $lastCode = $assign; if ($tokens[$assign]['code'] === T_SEMICOLON) { if ($tokens[$assign]['conditions'] === $tokens[$stackPtr]['conditions']) { if ($lastSemi !== null && $prevAssign !== null && $lastSemi > $prevAssign) { // This statement did not have an assignment operator in it. break; } else { $lastSemi = $assign; } } else if ($tokens[$assign]['level'] < $tokens[$stackPtr]['level']) { // Statement is in a different context, so the block is over. break; } } }//end if continue; } else if ($assign !== $stackPtr && $tokens[$assign]['line'] === $lastLine) { // Skip multiple assignments on the same line. We only need to // try and align the first assignment. continue; }//end if if ($assign !== $stackPtr) { if ($tokens[$assign]['level'] > $tokens[$stackPtr]['level']) { // Has to be nested inside the same conditions as the first assignment. // We've gone one level down, so process this new block. $assign = $this->checkAlignment($phpcsFile, $assign); $lastCode = $assign; continue; } else if ($tokens[$assign]['level'] < $tokens[$stackPtr]['level']) { // We've gone one level up, so the block we are processing is done. break; } else if ($arrayEnd !== null) { // Assignments inside arrays are not part of // the original block, so process this new block. $assign = ($this->checkAlignment($phpcsFile, $assign, $arrayEnd) - 1); $arrayEnd = null; $lastCode = $assign; continue; } // Make sure it is not assigned inside a condition (eg. IF, FOR). if (isset($tokens[$assign]['nested_parenthesis']) === true) { // If the parenthesis is on the same line as the assignment, // then it should be ignored as it is specifically being grouped. $parens = $tokens[$assign]['nested_parenthesis']; $lastParen = array_pop($parens); if ($tokens[$lastParen]['line'] === $tokens[$assign]['line']) { break; } foreach ($tokens[$assign]['nested_parenthesis'] as $start => $end) { if (isset($tokens[$start]['parenthesis_owner']) === true) { break(2); } } } }//end if $var = $phpcsFile->findPrevious( Tokens::$emptyTokens, ($assign - 1), null, true ); // Make sure we wouldn't break our max padding length if we // aligned with this statement, or they wouldn't break the max // padding length if they aligned with us. $varEnd = $tokens[($var + 1)]['column']; $assignLen = $tokens[$assign]['length']; if ($assign !== $stackPtr) { if ($prevAssign === null) { // Processing an inner block but no assignments found. break; } if (($varEnd + 1) > $assignments[$prevAssign]['assign_col']) { $padding = 1; $assignColumn = ($varEnd + 1); } else { $padding = ($assignments[$prevAssign]['assign_col'] - $varEnd + $assignments[$prevAssign]['assign_len'] - $assignLen); if ($padding <= 0) { $padding = 1; } if ($padding > $this->maxPadding) { $stopped = $assign; break; } $assignColumn = ($varEnd + $padding); }//end if if (($assignColumn + $assignLen) > ($assignments[$maxPadding]['assign_col'] + $assignments[$maxPadding]['assign_len'])) { $newPadding = ($varEnd - $assignments[$maxPadding]['var_end'] + $assignLen - $assignments[$maxPadding]['assign_len'] + 1); if ($newPadding > $this->maxPadding) { $stopped = $assign; break; } else { // New alignment settings for previous assignments. foreach ($assignments as $i => $data) { if ($i === $assign) { break; } $newPadding = ($varEnd - $data['var_end'] + $assignLen - $data['assign_len'] + 1); $assignments[$i]['expected'] = $newPadding; $assignments[$i]['assign_col'] = ($data['var_end'] + $newPadding); } $padding = 1; $assignColumn = ($varEnd + 1); } } else if ($padding > $assignments[$maxPadding]['expected']) { $maxPadding = $assign; }//end if } else { $padding = 1; $assignColumn = ($varEnd + 1); $maxPadding = $assign; }//end if $found = 0; if ($tokens[($var + 1)]['code'] === T_WHITESPACE) { $found = $tokens[($var + 1)]['length']; if ($found === 0) { // This means a newline was found. $found = 1; } } $assignments[$assign] = [ 'var_end' => $varEnd, 'assign_len' => $assignLen, 'assign_col' => $assignColumn, 'expected' => $padding, 'found' => $found, ]; $lastLine = $tokens[$assign]['line']; $prevAssign = $assign; }//end for if (empty($assignments) === true) { return $stackPtr; } $numAssignments = count($assignments); $errorGenerated = false; foreach ($assignments as $assignment => $data) { if ($data['found'] === $data['expected']) { continue; } $expectedText = $data['expected'].' space'; if ($data['expected'] !== 1) { $expectedText .= 's'; } if ($data['found'] === null) { $foundText = 'a new line'; } else { $foundText = $data['found'].' space'; if ($data['found'] !== 1) { $foundText .= 's'; } } if ($numAssignments === 1) { $type = 'Incorrect'; $error = 'Equals sign not aligned correctly; expected %s but found %s'; } else { $type = 'NotSame'; $error = 'Equals sign not aligned with surrounding assignments; expected %s but found %s'; } $errorData = [ $expectedText, $foundText, ]; if ($this->error === true) { $fix = $phpcsFile->addFixableError($error, $assignment, $type, $errorData); } else { $fix = $phpcsFile->addFixableWarning($error, $assignment, $type.'Warning', $errorData); } $errorGenerated = true; if ($fix === true && $data['found'] !== null) { $newContent = str_repeat(' ', $data['expected']); if ($data['found'] === 0) { $phpcsFile->fixer->addContentBefore($assignment, $newContent); } else { $phpcsFile->fixer->replaceToken(($assignment - 1), $newContent); } } }//end foreach if ($numAssignments > 1) { if ($errorGenerated === true) { $phpcsFile->recordMetric($stackPtr, 'Adjacent assignments aligned', 'no'); } else { $phpcsFile->recordMetric($stackPtr, 'Adjacent assignments aligned', 'yes'); } } if ($stopped !== null) { return $this->checkAlignment($phpcsFile, $stopped); } else { return $assign; } }//end checkAlignment() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Formatting/NoSpaceAfterCastSniff.php0000644000076500000240000000322613614652361030573 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence * * @deprecated 3.4.0 Use the Generic.Formatting.SpaceAfterCast sniff with * the $spacing property set to 0 instead. */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Formatting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class NoSpaceAfterCastSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return Tokens::$castTokens; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if ($tokens[($stackPtr + 1)]['code'] !== T_WHITESPACE) { return; } $error = 'A cast statement must not be followed by a space'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceFound'); if ($fix === true) { $phpcsFile->fixer->replaceToken(($stackPtr + 1), ''); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Formatting/SpaceAfterCastSniff.php0000644000076500000240000001107413614652361030276 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Formatting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class SpaceAfterCastSniff implements Sniff { /** * The number of spaces desired after a cast token. * * @var integer */ public $spacing = 1; /** * Allow newlines instead of spaces. * * @var boolean */ public $ignoreNewlines = false; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return Tokens::$castTokens; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $this->spacing = (int) $this->spacing; if ($tokens[$stackPtr]['code'] === T_BINARY_CAST && $tokens[$stackPtr]['content'] === 'b' ) { // You can't replace a space after this type of binary casting. return; } $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true); if ($nextNonEmpty === false) { return; } if ($this->ignoreNewlines === true && $tokens[$stackPtr]['line'] !== $tokens[$nextNonEmpty]['line'] ) { $phpcsFile->recordMetric($stackPtr, 'Spacing after cast statement', 'newline'); return; } if ($this->spacing === 0 && $nextNonEmpty === ($stackPtr + 1)) { $phpcsFile->recordMetric($stackPtr, 'Spacing after cast statement', 0); return; } $nextNonWhitespace = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($nextNonEmpty !== $nextNonWhitespace) { $error = 'Expected %s space(s) after cast statement; comment found'; $data = [$this->spacing]; $phpcsFile->addError($error, $stackPtr, 'CommentFound', $data); if ($tokens[($stackPtr + 1)]['code'] === T_WHITESPACE) { $phpcsFile->recordMetric($stackPtr, 'Spacing after cast statement', $tokens[($stackPtr + 1)]['length']); } else { $phpcsFile->recordMetric($stackPtr, 'Spacing after cast statement', 0); } return; } $found = 0; if ($tokens[$stackPtr]['line'] !== $tokens[$nextNonEmpty]['line']) { $found = 'newline'; } else if ($tokens[($stackPtr + 1)]['code'] === T_WHITESPACE) { $found = $tokens[($stackPtr + 1)]['length']; } $phpcsFile->recordMetric($stackPtr, 'Spacing after cast statement', $found); if ($found === $this->spacing) { return; } $error = 'Expected %s space(s) after cast statement; %s found'; $data = [ $this->spacing, $found, ]; $errorCode = 'TooMuchSpace'; if ($this->spacing !== 0) { if ($found === 0) { $errorCode = 'NoSpace'; } else if ($found !== 'newline' && $found < $this->spacing) { $errorCode = 'TooLittleSpace'; } } $fix = $phpcsFile->addFixableError($error, $stackPtr, $errorCode, $data); if ($fix === true) { $padding = str_repeat(' ', $this->spacing); if ($found === 0) { $phpcsFile->fixer->addContent($stackPtr, $padding); } else { $phpcsFile->fixer->beginChangeset(); $start = ($stackPtr + 1); if ($this->spacing > 0) { $phpcsFile->fixer->replaceToken($start, $padding); ++$start; } for ($i = $start; $i < $nextNonWhitespace; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Formatting/SpaceAfterNotSniff.php0000644000076500000240000000722413614652361030146 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Formatting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class SpaceAfterNotSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * The number of spaces desired after the NOT operator. * * @var integer */ public $spacing = 1; /** * Allow newlines instead of spaces. * * @var boolean */ public $ignoreNewlines = false; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_BOOLEAN_NOT]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $this->spacing = (int) $this->spacing; $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true); if ($nextNonEmpty === false) { return; } if ($this->ignoreNewlines === true && $tokens[$stackPtr]['line'] !== $tokens[$nextNonEmpty]['line'] ) { return; } if ($this->spacing === 0 && $nextNonEmpty === ($stackPtr + 1)) { return; } $nextNonWhitespace = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($nextNonEmpty !== $nextNonWhitespace) { $error = 'Expected %s space(s) after NOT operator; comment found'; $data = [$this->spacing]; $phpcsFile->addError($error, $stackPtr, 'CommentFound', $data); return; } $found = 0; if ($tokens[$stackPtr]['line'] !== $tokens[$nextNonEmpty]['line']) { $found = 'newline'; } else if ($tokens[($stackPtr + 1)]['code'] === T_WHITESPACE) { $found = $tokens[($stackPtr + 1)]['length']; } if ($found === $this->spacing) { return; } $error = 'Expected %s space(s) after NOT operator; %s found'; $data = [ $this->spacing, $found, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Incorrect', $data); if ($fix === true) { $padding = str_repeat(' ', $this->spacing); if ($found === 0) { $phpcsFile->fixer->addContent($stackPtr, $padding); } else { $phpcsFile->fixer->beginChangeset(); $start = ($stackPtr + 1); if ($this->spacing > 0) { $phpcsFile->fixer->replaceToken($start, $padding); ++$start; } for ($i = $start; $i < $nextNonWhitespace; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Formatting/SpaceBeforeCastSniff.php0000644000076500000240000000430413614652361030435 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Formatting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class SpaceBeforeCastSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return Tokens::$castTokens; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if ($tokens[$stackPtr]['column'] === 1) { return; } if ($tokens[($stackPtr - 1)]['code'] !== T_WHITESPACE) { $error = 'A cast statement must be preceded by a single space'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NoSpace'); if ($fix === true) { $phpcsFile->fixer->addContentBefore($stackPtr, ' '); } $phpcsFile->recordMetric($stackPtr, 'Spacing before cast statement', 0); return; } $phpcsFile->recordMetric($stackPtr, 'Spacing before cast statement', $tokens[($stackPtr - 1)]['length']); if ($tokens[($stackPtr - 1)]['column'] !== 1 && $tokens[($stackPtr - 1)]['length'] !== 1) { $error = 'A cast statement must be preceded by a single space'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'TooMuchSpace'); if ($fix === true) { $phpcsFile->fixer->replaceToken(($stackPtr - 1), ' '); } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Functions/CallTimePassByReferenceSniff.php0000644000076500000240000001072713614652361031743 0ustar gsherwoodstaff * @copyright 2009-2014 Florian Grandel * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Functions; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class CallTimePassByReferenceSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_STRING, T_VARIABLE, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $findTokens = Tokens::$emptyTokens; $findTokens[] = T_BITWISE_AND; $prev = $phpcsFile->findPrevious($findTokens, ($stackPtr - 1), null, true); // Skip tokens that are the names of functions or classes // within their definitions. For example: function myFunction... // "myFunction" is T_STRING but we should skip because it is not a // function or method *call*. $prevCode = $tokens[$prev]['code']; if ($prevCode === T_FUNCTION || $prevCode === T_CLASS) { return; } // If the next non-whitespace token after the function or method call // is not an opening parenthesis then it cant really be a *call*. $functionName = $stackPtr; $openBracket = $phpcsFile->findNext( Tokens::$emptyTokens, ($functionName + 1), null, true ); if ($tokens[$openBracket]['code'] !== T_OPEN_PARENTHESIS) { return; } if (isset($tokens[$openBracket]['parenthesis_closer']) === false) { return; } $closeBracket = $tokens[$openBracket]['parenthesis_closer']; $nextSeparator = $openBracket; $find = [ T_VARIABLE, T_OPEN_SHORT_ARRAY, ]; while (($nextSeparator = $phpcsFile->findNext($find, ($nextSeparator + 1), $closeBracket)) !== false) { if (isset($tokens[$nextSeparator]['nested_parenthesis']) === false) { continue; } if ($tokens[$nextSeparator]['code'] === T_OPEN_SHORT_ARRAY) { $nextSeparator = $tokens[$nextSeparator]['bracket_closer']; continue; } // Make sure the variable belongs directly to this function call // and is not inside a nested function call or array. $brackets = $tokens[$nextSeparator]['nested_parenthesis']; $lastBracket = array_pop($brackets); if ($lastBracket !== $closeBracket) { continue; } $tokenBefore = $phpcsFile->findPrevious( Tokens::$emptyTokens, ($nextSeparator - 1), null, true ); if ($tokens[$tokenBefore]['code'] === T_BITWISE_AND) { if ($phpcsFile->isReference($tokenBefore) === false) { continue; } // We also want to ignore references used in assignment // operations passed as function arguments, but isReference() // sees them as valid references (which they are). $tokenBefore = $phpcsFile->findPrevious( Tokens::$emptyTokens, ($tokenBefore - 1), null, true ); if (isset(Tokens::$assignmentTokens[$tokens[$tokenBefore]['code']]) === true) { continue; } // T_BITWISE_AND represents a pass-by-reference. $error = 'Call-time pass-by-reference calls are prohibited'; $phpcsFile->addError($error, $tokenBefore, 'NotAllowed'); }//end if }//end while }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Functions/FunctionCallArgumentSpacingSniff.php0000644000076500000240000001631013614652361032673 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Functions; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class FunctionCallArgumentSpacingSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return[ T_STRING, T_ISSET, T_UNSET, T_SELF, T_STATIC, T_VARIABLE, T_CLOSE_CURLY_BRACKET, T_CLOSE_PARENTHESIS, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Skip tokens that are the names of functions or classes // within their definitions. For example: // function myFunction... // "myFunction" is T_STRING but we should skip because it is not a // function or method *call*. $functionName = $stackPtr; $ignoreTokens = Tokens::$emptyTokens; $ignoreTokens[] = T_BITWISE_AND; $functionKeyword = $phpcsFile->findPrevious($ignoreTokens, ($stackPtr - 1), null, true); if ($tokens[$functionKeyword]['code'] === T_FUNCTION || $tokens[$functionKeyword]['code'] === T_CLASS) { return; } if ($tokens[$stackPtr]['code'] === T_CLOSE_CURLY_BRACKET && isset($tokens[$stackPtr]['scope_condition']) === true ) { // Not a function call. return; } // If the next non-whitespace token after the function or method call // is not an opening parenthesis then it can't really be a *call*. $openBracket = $phpcsFile->findNext(Tokens::$emptyTokens, ($functionName + 1), null, true); if ($tokens[$openBracket]['code'] !== T_OPEN_PARENTHESIS) { return; } if (isset($tokens[$openBracket]['parenthesis_closer']) === false) { return; } $this->checkSpacing($phpcsFile, $stackPtr, $openBracket); }//end process() /** * Checks the spacing around commas. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * @param int $openBracket The position of the opening bracket * in the stack passed in $tokens. * * @return void */ public function checkSpacing(File $phpcsFile, $stackPtr, $openBracket) { $tokens = $phpcsFile->getTokens(); $closeBracket = $tokens[$openBracket]['parenthesis_closer']; $nextSeparator = $openBracket; $find = [ T_COMMA, T_CLOSURE, T_ANON_CLASS, T_OPEN_SHORT_ARRAY, ]; while (($nextSeparator = $phpcsFile->findNext($find, ($nextSeparator + 1), $closeBracket)) !== false) { if ($tokens[$nextSeparator]['code'] === T_CLOSURE || $tokens[$nextSeparator]['code'] === T_ANON_CLASS ) { // Skip closures. $nextSeparator = $tokens[$nextSeparator]['scope_closer']; continue; } else if ($tokens[$nextSeparator]['code'] === T_OPEN_SHORT_ARRAY) { // Skips arrays using short notation. $nextSeparator = $tokens[$nextSeparator]['bracket_closer']; continue; } // Make sure the comma or variable belongs directly to this function call, // and is not inside a nested function call or array. $brackets = $tokens[$nextSeparator]['nested_parenthesis']; $lastBracket = array_pop($brackets); if ($lastBracket !== $closeBracket) { continue; } if ($tokens[$nextSeparator]['code'] === T_COMMA) { if ($tokens[($nextSeparator - 1)]['code'] === T_WHITESPACE) { $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($nextSeparator - 2), null, true); if (isset(Tokens::$heredocTokens[$tokens[$prev]['code']]) === false) { $error = 'Space found before comma in argument list'; $fix = $phpcsFile->addFixableError($error, $nextSeparator, 'SpaceBeforeComma'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); if ($tokens[$prev]['line'] !== $tokens[$nextSeparator]['line']) { $phpcsFile->fixer->addContent($prev, ','); $phpcsFile->fixer->replaceToken($nextSeparator, ''); } else { $phpcsFile->fixer->replaceToken(($nextSeparator - 1), ''); } $phpcsFile->fixer->endChangeset(); } }//end if }//end if if ($tokens[($nextSeparator + 1)]['code'] !== T_WHITESPACE) { $error = 'No space found after comma in argument list'; $fix = $phpcsFile->addFixableError($error, $nextSeparator, 'NoSpaceAfterComma'); if ($fix === true) { $phpcsFile->fixer->addContent($nextSeparator, ' '); } } else { // If there is a newline in the space, then they must be formatting // each argument on a newline, which is valid, so ignore it. $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($nextSeparator + 1), null, true); if ($tokens[$next]['line'] === $tokens[$nextSeparator]['line']) { $space = $tokens[($nextSeparator + 1)]['length']; if ($space > 1) { $error = 'Expected 1 space after comma in argument list; %s found'; $data = [$space]; $fix = $phpcsFile->addFixableError($error, $nextSeparator, 'TooMuchSpaceAfterComma', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($nextSeparator + 1), ' '); } } } }//end if }//end if }//end while }//end checkSpacing() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Functions/OpeningFunctionBraceBsdAllmanSniff.php0000644000076500000240000001730613614652361033130 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Functions; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class OpeningFunctionBraceBsdAllmanSniff implements Sniff { /** * Should this sniff check function braces? * * @var boolean */ public $checkFunctions = true; /** * Should this sniff check closure braces? * * @var boolean */ public $checkClosures = false; /** * Registers the tokens that this sniff wants to listen for. * * @return int[] */ public function register() { return [ T_FUNCTION, T_CLOSURE, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['scope_opener']) === false) { return; } if (($tokens[$stackPtr]['code'] === T_FUNCTION && (bool) $this->checkFunctions === false) || ($tokens[$stackPtr]['code'] === T_CLOSURE && (bool) $this->checkClosures === false) ) { return; } $openingBrace = $tokens[$stackPtr]['scope_opener']; $closeBracket = $tokens[$stackPtr]['parenthesis_closer']; if ($tokens[$stackPtr]['code'] === T_CLOSURE) { $use = $phpcsFile->findNext(T_USE, ($closeBracket + 1), $tokens[$stackPtr]['scope_opener']); if ($use !== false) { $openBracket = $phpcsFile->findNext(T_OPEN_PARENTHESIS, ($use + 1)); $closeBracket = $tokens[$openBracket]['parenthesis_closer']; } } // Find the end of the function declaration. $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($openingBrace - 1), $closeBracket, true); $functionLine = $tokens[$prev]['line']; $braceLine = $tokens[$openingBrace]['line']; $lineDifference = ($braceLine - $functionLine); $metricType = 'Function'; if ($tokens[$stackPtr]['code'] === T_CLOSURE) { $metricType = 'Closure'; } if ($lineDifference === 0) { $error = 'Opening brace should be on a new line'; $fix = $phpcsFile->addFixableError($error, $openingBrace, 'BraceOnSameLine'); if ($fix === true) { $hasTrailingAnnotation = false; for ($nextLine = ($openingBrace + 1); $nextLine < $phpcsFile->numTokens; $nextLine++) { if ($tokens[$openingBrace]['line'] !== $tokens[$nextLine]['line']) { break; } if (isset(Tokens::$phpcsCommentTokens[$tokens[$nextLine]['code']]) === true) { $hasTrailingAnnotation = true; } } $phpcsFile->fixer->beginChangeset(); $indent = $phpcsFile->findFirstOnLine([], $openingBrace); if ($hasTrailingAnnotation === false || $nextLine === false) { if ($tokens[$indent]['code'] === T_WHITESPACE) { $phpcsFile->fixer->addContentBefore($openingBrace, $tokens[$indent]['content']); } if ($tokens[($openingBrace - 1)]['code'] === T_WHITESPACE) { $phpcsFile->fixer->replaceToken(($openingBrace - 1), ''); } $phpcsFile->fixer->addNewlineBefore($openingBrace); } else { $phpcsFile->fixer->replaceToken($openingBrace, ''); $phpcsFile->fixer->addNewlineBefore($nextLine); $phpcsFile->fixer->addContentBefore($nextLine, '{'); if ($tokens[$indent]['code'] === T_WHITESPACE) { $phpcsFile->fixer->addContentBefore($nextLine, $tokens[$indent]['content']); } } $phpcsFile->fixer->endChangeset(); }//end if $phpcsFile->recordMetric($stackPtr, "$metricType opening brace placement", 'same line'); } else if ($lineDifference > 1) { $error = 'Opening brace should be on the line after the declaration; found %s blank line(s)'; $data = [($lineDifference - 1)]; $fix = $phpcsFile->addFixableError($error, $openingBrace, 'BraceSpacing', $data); if ($fix === true) { for ($i = ($tokens[$stackPtr]['parenthesis_closer'] + 1); $i < $openingBrace; $i++) { if ($tokens[$i]['line'] === $braceLine) { $phpcsFile->fixer->addNewLineBefore($i); break; } $phpcsFile->fixer->replaceToken($i, ''); } } }//end if $ignore = Tokens::$phpcsCommentTokens; $ignore[] = T_WHITESPACE; $next = $phpcsFile->findNext($ignore, ($openingBrace + 1), null, true); if ($tokens[$next]['line'] === $tokens[$openingBrace]['line']) { if ($next === $tokens[$stackPtr]['scope_closer']) { // Ignore empty functions. return; } $error = 'Opening brace must be the last content on the line'; $fix = $phpcsFile->addFixableError($error, $openingBrace, 'ContentAfterBrace'); if ($fix === true) { $phpcsFile->fixer->addNewline($openingBrace); } } // Only continue checking if the opening brace looks good. if ($lineDifference !== 1) { return; } // We need to actually find the first piece of content on this line, // as if this is a method with tokens before it (public, static etc) // or an if with an else before it, then we need to start the scope // checking from there, rather than the current token. $lineStart = $phpcsFile->findFirstOnLine(T_WHITESPACE, $stackPtr, true); // The opening brace is on the correct line, now it needs to be // checked to be correctly indented. $startColumn = $tokens[$lineStart]['column']; $braceIndent = $tokens[$openingBrace]['column']; if ($braceIndent !== $startColumn) { $expected = ($startColumn - 1); $found = ($braceIndent - 1); $error = 'Opening brace indented incorrectly; expected %s spaces, found %s'; $data = [ $expected, $found, ]; $fix = $phpcsFile->addFixableError($error, $openingBrace, 'BraceIndent', $data); if ($fix === true) { $indent = str_repeat(' ', $expected); if ($found === 0) { $phpcsFile->fixer->addContentBefore($openingBrace, $indent); } else { $phpcsFile->fixer->replaceToken(($openingBrace - 1), $indent); } } }//end if $phpcsFile->recordMetric($stackPtr, "$metricType opening brace placement", 'new line'); }//end process() }//end class ././@LongLink0000000000000000000000000000015200000000000007753 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Functions/OpeningFunctionBraceKernighanRitchieSniff.phpPHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Functions/OpeningFunctionBraceKernighanRitchieSni0000644000076500000240000001515713614652361033411 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Functions; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class OpeningFunctionBraceKernighanRitchieSniff implements Sniff { /** * Should this sniff check function braces? * * @var boolean */ public $checkFunctions = true; /** * Should this sniff check closure braces? * * @var boolean */ public $checkClosures = false; /** * Registers the tokens that this sniff wants to listen for. * * @return void */ public function register() { return [ T_FUNCTION, T_CLOSURE, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['scope_opener']) === false) { return; } if (($tokens[$stackPtr]['code'] === T_FUNCTION && (bool) $this->checkFunctions === false) || ($tokens[$stackPtr]['code'] === T_CLOSURE && (bool) $this->checkClosures === false) ) { return; } $openingBrace = $tokens[$stackPtr]['scope_opener']; $closeBracket = $tokens[$stackPtr]['parenthesis_closer']; if ($tokens[$stackPtr]['code'] === T_CLOSURE) { $use = $phpcsFile->findNext(T_USE, ($closeBracket + 1), $tokens[$stackPtr]['scope_opener']); if ($use !== false) { $openBracket = $phpcsFile->findNext(T_OPEN_PARENTHESIS, ($use + 1)); $closeBracket = $tokens[$openBracket]['parenthesis_closer']; } } // Find the end of the function declaration. $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($openingBrace - 1), $closeBracket, true); $functionLine = $tokens[$prev]['line']; $braceLine = $tokens[$openingBrace]['line']; $lineDifference = ($braceLine - $functionLine); $metricType = 'Function'; if ($tokens[$stackPtr]['code'] === T_CLOSURE) { $metricType = 'Closure'; } if ($lineDifference > 0) { $phpcsFile->recordMetric($stackPtr, "$metricType opening brace placement", 'new line'); $error = 'Opening brace should be on the same line as the declaration'; $fix = $phpcsFile->addFixableError($error, $openingBrace, 'BraceOnNewLine'); if ($fix === true) { $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($openingBrace - 1), $closeBracket, true); $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->addContent($prev, ' {'); $phpcsFile->fixer->replaceToken($openingBrace, ''); if ($tokens[($openingBrace + 1)]['code'] === T_WHITESPACE && $tokens[($openingBrace + 2)]['line'] > $tokens[$openingBrace]['line'] ) { // Brace is followed by a new line, so remove it to ensure we don't // leave behind a blank line at the top of the block. $phpcsFile->fixer->replaceToken(($openingBrace + 1), ''); if ($tokens[($openingBrace - 1)]['code'] === T_WHITESPACE && $tokens[($openingBrace - 1)]['line'] === $tokens[$openingBrace]['line'] && $tokens[($openingBrace - 2)]['line'] < $tokens[$openingBrace]['line'] ) { // Brace is preceded by indent, so remove it to ensure we don't // leave behind more indent than is required for the first line. $phpcsFile->fixer->replaceToken(($openingBrace - 1), ''); } } $phpcsFile->fixer->endChangeset(); }//end if } else { $phpcsFile->recordMetric($stackPtr, "$metricType opening brace placement", 'same line'); }//end if $ignore = Tokens::$phpcsCommentTokens; $ignore[] = T_WHITESPACE; $next = $phpcsFile->findNext($ignore, ($openingBrace + 1), null, true); if ($tokens[$next]['line'] === $tokens[$openingBrace]['line']) { if ($next === $tokens[$stackPtr]['scope_closer'] || $tokens[$next]['code'] === T_CLOSE_TAG ) { // Ignore empty functions. return; } $error = 'Opening brace must be the last content on the line'; $fix = $phpcsFile->addFixableError($error, $openingBrace, 'ContentAfterBrace'); if ($fix === true) { $phpcsFile->fixer->addNewline($openingBrace); } } // Only continue checking if the opening brace looks good. if ($lineDifference > 0) { return; } // We are looking for tabs, even if they have been replaced, because // we enforce a space here. if (isset($tokens[($openingBrace - 1)]['orig_content']) === true) { $spacing = $tokens[($openingBrace - 1)]['orig_content']; } else { $spacing = $tokens[($openingBrace - 1)]['content']; } if ($tokens[($openingBrace - 1)]['code'] !== T_WHITESPACE) { $length = 0; } else if ($spacing === "\t") { $length = '\t'; } else { $length = strlen($spacing); } if ($length !== 1) { $error = 'Expected 1 space before opening brace; found %s'; $data = [$length]; $fix = $phpcsFile->addFixableError($error, $closeBracket, 'SpaceBeforeBrace', $data); if ($fix === true) { if ($length === 0 || $length === '\t') { $phpcsFile->fixer->addContentBefore($openingBrace, ' '); } else { $phpcsFile->fixer->replaceToken(($openingBrace - 1), ' '); } } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Metrics/CyclomaticComplexitySniff.php0000644000076500000240000000627213614652361031113 0ustar gsherwoodstaff * @author Greg Sherwood * @copyright 2007-2014 Mayflower GmbH * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Metrics; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class CyclomaticComplexitySniff implements Sniff { /** * A complexity higher than this value will throw a warning. * * @var integer */ public $complexity = 10; /** * A complexity higher than this value will throw an error. * * @var integer */ public $absoluteComplexity = 20; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_FUNCTION]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Ignore abstract methods. if (isset($tokens[$stackPtr]['scope_opener']) === false) { return; } // Detect start and end of this function definition. $start = $tokens[$stackPtr]['scope_opener']; $end = $tokens[$stackPtr]['scope_closer']; // Predicate nodes for PHP. $find = [ T_CASE => true, T_DEFAULT => true, T_CATCH => true, T_IF => true, T_FOR => true, T_FOREACH => true, T_WHILE => true, T_DO => true, T_ELSEIF => true, ]; $complexity = 1; // Iterate from start to end and count predicate nodes. for ($i = ($start + 1); $i < $end; $i++) { if (isset($find[$tokens[$i]['code']]) === true) { $complexity++; } } if ($complexity > $this->absoluteComplexity) { $error = 'Function\'s cyclomatic complexity (%s) exceeds allowed maximum of %s'; $data = [ $complexity, $this->absoluteComplexity, ]; $phpcsFile->addError($error, $stackPtr, 'MaxExceeded', $data); } else if ($complexity > $this->complexity) { $warning = 'Function\'s cyclomatic complexity (%s) exceeds %s; consider refactoring the function'; $data = [ $complexity, $this->complexity, ]; $phpcsFile->addWarning($warning, $stackPtr, 'TooHigh', $data); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/Metrics/NestingLevelSniff.php0000644000076500000240000000553413614652361027345 0ustar gsherwoodstaff * @author Greg Sherwood * @copyright 2007-2014 Mayflower GmbH * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\Metrics; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class NestingLevelSniff implements Sniff { /** * A nesting level higher than this value will throw a warning. * * @var integer */ public $nestingLevel = 5; /** * A nesting level higher than this value will throw an error. * * @var integer */ public $absoluteNestingLevel = 10; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_FUNCTION]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Ignore abstract methods. if (isset($tokens[$stackPtr]['scope_opener']) === false) { return; } // Detect start and end of this function definition. $start = $tokens[$stackPtr]['scope_opener']; $end = $tokens[$stackPtr]['scope_closer']; $nestingLevel = 0; // Find the maximum nesting level of any token in the function. for ($i = ($start + 1); $i < $end; $i++) { $level = $tokens[$i]['level']; if ($nestingLevel < $level) { $nestingLevel = $level; } } // We subtract the nesting level of the function itself. $nestingLevel = ($nestingLevel - $tokens[$stackPtr]['level'] - 1); if ($nestingLevel > $this->absoluteNestingLevel) { $error = 'Function\'s nesting level (%s) exceeds allowed maximum of %s'; $data = [ $nestingLevel, $this->absoluteNestingLevel, ]; $phpcsFile->addError($error, $stackPtr, 'MaxExceeded', $data); } else if ($nestingLevel > $this->nestingLevel) { $warning = 'Function\'s nesting level (%s) exceeds %s; consider refactoring the function'; $data = [ $nestingLevel, $this->nestingLevel, ]; $phpcsFile->addWarning($warning, $stackPtr, 'TooHigh', $data); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/NamingConventions/CamelCapsFunctionNameSniff.php0000644000076500000240000001630313614652361033132 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\NamingConventions; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\AbstractScopeSniff; use PHP_CodeSniffer\Util\Common; use PHP_CodeSniffer\Util\Tokens; class CamelCapsFunctionNameSniff extends AbstractScopeSniff { /** * A list of all PHP magic methods. * * @var array */ protected $magicMethods = [ 'construct' => true, 'destruct' => true, 'call' => true, 'callstatic' => true, 'get' => true, 'set' => true, 'isset' => true, 'unset' => true, 'sleep' => true, 'wakeup' => true, 'tostring' => true, 'set_state' => true, 'clone' => true, 'invoke' => true, 'debuginfo' => true, ]; /** * A list of all PHP non-magic methods starting with a double underscore. * * These come from PHP modules such as SOAPClient. * * @var array */ protected $methodsDoubleUnderscore = [ 'dorequest' => true, 'getcookies' => true, 'getfunctions' => true, 'getlastrequest' => true, 'getlastrequestheaders' => true, 'getlastresponse' => true, 'getlastresponseheaders' => true, 'gettypes' => true, 'setcookie' => true, 'setlocation' => true, 'setsoapheaders' => true, 'soapcall' => true, ]; /** * A list of all PHP magic functions. * * @var array */ protected $magicFunctions = ['autoload' => true]; /** * If TRUE, the string must not have two capital letters next to each other. * * @var boolean */ public $strict = true; /** * Constructs a Generic_Sniffs_NamingConventions_CamelCapsFunctionNameSniff. */ public function __construct() { parent::__construct(Tokens::$ooScopeTokens, [T_FUNCTION], true); }//end __construct() /** * Processes the tokens within the scope. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being processed. * @param int $stackPtr The position where this token was * found. * @param int $currScope The position of the current scope. * * @return void */ protected function processTokenWithinScope(File $phpcsFile, $stackPtr, $currScope) { $tokens = $phpcsFile->getTokens(); // Determine if this is a function which needs to be examined. $conditions = $tokens[$stackPtr]['conditions']; end($conditions); $deepestScope = key($conditions); if ($deepestScope !== $currScope) { return; } $methodName = $phpcsFile->getDeclarationName($stackPtr); if ($methodName === null) { // Ignore closures. return; } $className = $phpcsFile->getDeclarationName($currScope); if (isset($className) === false) { $className = '[Anonymous Class]'; } $errorData = [$className.'::'.$methodName]; $methodNameLc = strtolower($methodName); $classNameLc = strtolower($className); // Is this a magic method. i.e., is prefixed with "__" ? if (preg_match('|^__[^_]|', $methodName) !== 0) { $magicPart = substr($methodNameLc, 2); if (isset($this->magicMethods[$magicPart]) === true || isset($this->methodsDoubleUnderscore[$magicPart]) === true ) { return; } $error = 'Method name "%s" is invalid; only PHP magic methods should be prefixed with a double underscore'; $phpcsFile->addError($error, $stackPtr, 'MethodDoubleUnderscore', $errorData); } // PHP4 constructors are allowed to break our rules. if ($methodNameLc === $classNameLc) { return; } // PHP4 destructors are allowed to break our rules. if ($methodNameLc === '_'.$classNameLc) { return; } // Ignore first underscore in methods prefixed with "_". $methodName = ltrim($methodName, '_'); $methodProps = $phpcsFile->getMethodProperties($stackPtr); if (Common::isCamelCaps($methodName, false, true, $this->strict) === false) { if ($methodProps['scope_specified'] === true) { $error = '%s method name "%s" is not in camel caps format'; $data = [ ucfirst($methodProps['scope']), $errorData[0], ]; $phpcsFile->addError($error, $stackPtr, 'ScopeNotCamelCaps', $data); } else { $error = 'Method name "%s" is not in camel caps format'; $phpcsFile->addError($error, $stackPtr, 'NotCamelCaps', $errorData); } $phpcsFile->recordMetric($stackPtr, 'CamelCase method name', 'no'); return; } else { $phpcsFile->recordMetric($stackPtr, 'CamelCase method name', 'yes'); } }//end processTokenWithinScope() /** * Processes the tokens outside the scope. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being processed. * @param int $stackPtr The position where this token was * found. * * @return void */ protected function processTokenOutsideScope(File $phpcsFile, $stackPtr) { $functionName = $phpcsFile->getDeclarationName($stackPtr); if ($functionName === null) { // Ignore closures. return; } $errorData = [$functionName]; // Is this a magic function. i.e., it is prefixed with "__". if (preg_match('|^__[^_]|', $functionName) !== 0) { $magicPart = strtolower(substr($functionName, 2)); if (isset($this->magicFunctions[$magicPart]) === true) { return; } $error = 'Function name "%s" is invalid; only PHP magic methods should be prefixed with a double underscore'; $phpcsFile->addError($error, $stackPtr, 'FunctionDoubleUnderscore', $errorData); } // Ignore first underscore in functions prefixed with "_". $functionName = ltrim($functionName, '_'); if (Common::isCamelCaps($functionName, false, true, $this->strict) === false) { $error = 'Function name "%s" is not in camel caps format'; $phpcsFile->addError($error, $stackPtr, 'NotCamelCaps', $errorData); $phpcsFile->recordMetric($stackPtr, 'CamelCase function name', 'no'); } else { $phpcsFile->recordMetric($stackPtr, 'CamelCase method name', 'yes'); } }//end processTokenOutsideScope() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/NamingConventions/ConstructorNameSniff.php0000644000076500000240000001234413614652361032122 0ustar gsherwoodstaff * @author Leif Wickland * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\NamingConventions; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\AbstractScopeSniff; class ConstructorNameSniff extends AbstractScopeSniff { /** * The name of the class we are currently checking. * * @var string */ private $currentClass = ''; /** * A list of functions in the current class. * * @var string[] */ private $functionList = []; /** * Constructs the test with the tokens it wishes to listen for. */ public function __construct() { parent::__construct([T_CLASS, T_ANON_CLASS], [T_FUNCTION], true); }//end __construct() /** * Processes this test when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param int $currScope A pointer to the start of the scope. * * @return void */ protected function processTokenWithinScope(File $phpcsFile, $stackPtr, $currScope) { $tokens = $phpcsFile->getTokens(); // Determine if this is a function which needs to be examined. $conditions = $tokens[$stackPtr]['conditions']; end($conditions); $deepestScope = key($conditions); if ($deepestScope !== $currScope) { return; } $className = strtolower($phpcsFile->getDeclarationName($currScope)); if ($className !== $this->currentClass) { $this->loadFunctionNamesInScope($phpcsFile, $currScope); $this->currentClass = $className; } $methodName = strtolower($phpcsFile->getDeclarationName($stackPtr)); if ($methodName === $className) { if (in_array('__construct', $this->functionList, true) === false) { $error = 'PHP4 style constructors are not allowed; use "__construct()" instead'; $phpcsFile->addError($error, $stackPtr, 'OldStyle'); } } else if ($methodName !== '__construct') { // Not a constructor. return; } // Stop if the constructor doesn't have a body, like when it is abstract. if (isset($tokens[$stackPtr]['scope_closer']) === false) { return; } $parentClassName = strtolower($phpcsFile->findExtendedClassName($currScope)); if ($parentClassName === false) { return; } $endFunctionIndex = $tokens[$stackPtr]['scope_closer']; $startIndex = $stackPtr; while (($doubleColonIndex = $phpcsFile->findNext(T_DOUBLE_COLON, $startIndex, $endFunctionIndex)) !== false) { if ($tokens[($doubleColonIndex + 1)]['code'] === T_STRING && strtolower($tokens[($doubleColonIndex + 1)]['content']) === $parentClassName ) { $error = 'PHP4 style calls to parent constructors are not allowed; use "parent::__construct()" instead'; $phpcsFile->addError($error, ($doubleColonIndex + 1), 'OldStyleCall'); } $startIndex = ($doubleColonIndex + 1); } }//end processTokenWithinScope() /** * Processes a token that is found within the scope that this test is * listening to. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param int $stackPtr The position in the stack where this * token was found. * * @return void */ protected function processTokenOutsideScope(File $phpcsFile, $stackPtr) { }//end processTokenOutsideScope() /** * Extracts all the function names found in the given scope. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being scanned. * @param int $currScope A pointer to the start of the scope. * * @return void */ protected function loadFunctionNamesInScope(File $phpcsFile, $currScope) { $this->functionList = []; $tokens = $phpcsFile->getTokens(); for ($i = ($tokens[$currScope]['scope_opener'] + 1); $i < $tokens[$currScope]['scope_closer']; $i++) { if ($tokens[$i]['code'] !== T_FUNCTION) { continue; } $this->functionList[] = trim(strtolower($phpcsFile->getDeclarationName($i))); if (isset($tokens[$i]['scope_closer']) !== false) { // Skip past nested functions and such. $i = $tokens[$i]['scope_closer']; } } }//end loadFunctionNamesInScope() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/NamingConventions/UpperCaseConstantNameSniff.php0000644000076500000240000001115413614652361033174 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\NamingConventions; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class UpperCaseConstantNameSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_STRING, T_CONST, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if ($tokens[$stackPtr]['code'] === T_CONST) { // This is a class constant. $constant = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true); if ($constant === false) { return; } $constName = $tokens[$constant]['content']; if (strtoupper($constName) !== $constName) { if (strtolower($constName) === $constName) { $phpcsFile->recordMetric($constant, 'Constant name case', 'lower'); } else { $phpcsFile->recordMetric($constant, 'Constant name case', 'mixed'); } $error = 'Class constants must be uppercase; expected %s but found %s'; $data = [ strtoupper($constName), $constName, ]; $phpcsFile->addError($error, $constant, 'ClassConstantNotUpperCase', $data); } else { $phpcsFile->recordMetric($constant, 'Constant name case', 'upper'); } return; }//end if // Only interested in define statements now. if (strtolower($tokens[$stackPtr]['content']) !== 'define') { return; } // Make sure this is not a method call. $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true); if ($tokens[$prev]['code'] === T_OBJECT_OPERATOR || $tokens[$prev]['code'] === T_DOUBLE_COLON ) { return; } // If the next non-whitespace token after this token // is not an opening parenthesis then it is not a function call. $openBracket = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true); if ($openBracket === false) { return; } // The next non-whitespace token must be the constant name. $constPtr = $phpcsFile->findNext(T_WHITESPACE, ($openBracket + 1), null, true); if ($tokens[$constPtr]['code'] !== T_CONSTANT_ENCAPSED_STRING) { return; } $constName = $tokens[$constPtr]['content']; // Check for constants like self::CONSTANT. $prefix = ''; $splitPos = strpos($constName, '::'); if ($splitPos !== false) { $prefix = substr($constName, 0, ($splitPos + 2)); $constName = substr($constName, ($splitPos + 2)); } // Strip namespace from constant like /foo/bar/CONSTANT. $splitPos = strrpos($constName, '\\'); if ($splitPos !== false) { $prefix = substr($constName, 0, ($splitPos + 1)); $constName = substr($constName, ($splitPos + 1)); } if (strtoupper($constName) !== $constName) { if (strtolower($constName) === $constName) { $phpcsFile->recordMetric($stackPtr, 'Constant name case', 'lower'); } else { $phpcsFile->recordMetric($stackPtr, 'Constant name case', 'mixed'); } $error = 'Constants must be uppercase; expected %s but found %s'; $data = [ $prefix.strtoupper($constName), $prefix.$constName, ]; $phpcsFile->addError($error, $stackPtr, 'ConstantNotUpperCase', $data); } else { $phpcsFile->recordMetric($stackPtr, 'Constant name case', 'upper'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/PHP/BacktickOperatorSniff.php0000644000076500000240000000232113614652361027205 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\PHP; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class BacktickOperatorSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_BACKTICK]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $error = 'Use of the backtick operator is forbidden'; $phpcsFile->addError($error, $stackPtr, 'Found'); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/PHP/CharacterBeforePHPOpeningTagSniff.php0000644000076500000240000000462413614652361031331 0ustar gsherwoodstaff * @copyright 2010-2014 Andy Grunwald * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\PHP; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class CharacterBeforePHPOpeningTagSniff implements Sniff { /** * List of supported BOM definitions. * * Use encoding names as keys and hex BOM representations as values. * * @var array */ protected $bomDefinitions = [ 'UTF-8' => 'efbbbf', 'UTF-16 (BE)' => 'feff', 'UTF-16 (LE)' => 'fffe', ]; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return int */ public function process(File $phpcsFile, $stackPtr) { $expected = 0; if ($stackPtr > 0) { // Allow a byte-order mark. $tokens = $phpcsFile->getTokens(); foreach ($this->bomDefinitions as $bomName => $expectedBomHex) { $bomByteLength = (strlen($expectedBomHex) / 2); $htmlBomHex = bin2hex(substr($tokens[0]['content'], 0, $bomByteLength)); if ($htmlBomHex === $expectedBomHex) { $expected++; break; } } // Allow a shebang line. if (substr($tokens[0]['content'], 0, 2) === '#!') { $expected++; } } if ($stackPtr !== $expected) { $error = 'The opening PHP tag must be the first content in the file'; $phpcsFile->addError($error, $stackPtr, 'Found'); } // Skip the rest of the file so we don't pick up additional // open tags, typically embedded in HTML. return $phpcsFile->numTokens; }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/PHP/ClosingPHPTagSniff.php0000644000076500000240000000251613614652361026366 0ustar gsherwoodstaff * @copyright 2010-2014 Stefano Kowalke * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\PHP; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class ClosingPHPTagSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $closeTag = $phpcsFile->findNext(T_CLOSE_TAG, $stackPtr); if ($closeTag === false) { $error = 'The PHP open tag does not have a corresponding PHP close tag'; $phpcsFile->addError($error, $stackPtr, 'NotFound'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/PHP/DeprecatedFunctionsSniff.php0000644000076500000240000000436313614652361027717 0ustar gsherwoodstaff * @author Greg Sherwood * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\PHP; class DeprecatedFunctionsSniff extends ForbiddenFunctionsSniff { /** * A list of forbidden functions with their alternatives. * * The value is NULL if no alternative exists. IE, the * function should just not be used. * * @var array */ public $forbiddenFunctions = []; /** * Constructor. * * Uses the Reflection API to get a list of deprecated functions. */ public function __construct() { $functions = get_defined_functions(); foreach ($functions['internal'] as $functionName) { $function = new \ReflectionFunction($functionName); if (method_exists($function, 'isDeprecated') === false) { break; } if ($function->isDeprecated() === true) { $this->forbiddenFunctions[$functionName] = null; } } }//end __construct() /** * Generates the error or warning for this sniff. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the forbidden function * in the token array. * @param string $function The name of the forbidden function. * @param string $pattern The pattern used for the match. * * @return void */ protected function addError($phpcsFile, $stackPtr, $function, $pattern=null) { $data = [$function]; $error = 'Function %s() has been deprecated'; $type = 'Deprecated'; if ($this->error === true) { $phpcsFile->addError($error, $stackPtr, $type, $data); } else { $phpcsFile->addWarning($error, $stackPtr, $type, $data); } }//end addError() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/PHP/DisallowRequestSuperglobalSniff.php0000644000076500000240000000250613614652361031312 0ustar gsherwoodstaff * @copyright 2006-2019 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\PHP; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class DisallowRequestSuperglobalSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_VARIABLE]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $varName = $tokens[$stackPtr]['content']; if ($varName !== '$_REQUEST') { return; } $error = 'The $_REQUEST superglobal should not be used; use $_GET, $_POST, or $_COOKIE instead'; $phpcsFile->addError($error, $stackPtr, 'Found'); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/PHP/DisallowShortOpenTagSniff.php0000644000076500000240000001262113614652361030036 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\PHP; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class DisallowShortOpenTagSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { $targets = [ T_OPEN_TAG, T_OPEN_TAG_WITH_ECHO, ]; $shortOpenTags = (bool) ini_get('short_open_tag'); if ($shortOpenTags === false) { $targets[] = T_INLINE_HTML; } return $targets; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $token = $tokens[$stackPtr]; if ($token['code'] === T_OPEN_TAG && $token['content'] === 'addFixableError($error, $stackPtr, 'Found', $data); if ($fix === true) { $correctOpening = 'fixer->replaceToken($stackPtr, $correctOpening); } $phpcsFile->recordMetric($stackPtr, 'PHP short open tag used', 'yes'); } else { $phpcsFile->recordMetric($stackPtr, 'PHP short open tag used', 'no'); } if ($token['code'] === T_OPEN_TAG_WITH_ECHO) { $nextVar = $tokens[$phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true)]; $error = 'Short PHP opening tag used with echo; expected "addFixableError($error, $stackPtr, 'EchoFound', $data); if ($fix === true) { if ($tokens[($stackPtr + 1)]['code'] !== T_WHITESPACE) { $phpcsFile->fixer->replaceToken($stackPtr, 'fixer->replaceToken($stackPtr, 'numTokens; $i++) { if ($tokens[$i]['code'] !== T_INLINE_HTML) { break; } $closerFound = strrpos($tokens[$i]['content'], '?>'); if ($closerFound !== false) { if ($i !== $stackPtr) { break; } else if ($closerFound > $openerFound) { break; } else { $closerFound = false; } } } if ($closerFound !== false) { $error = 'Possible use of short open tags detected; found: %s'; $snippet = $this->getSnippet($content, 'addWarning($error, $stackPtr, 'PossibleFound', $data); // Skip forward to the token containing the closer. if (($i - 1) > $stackPtr) { return $i; } } }//end if }//end process() /** * Get a snippet from a HTML token. * * @param string $content The content of the HTML token. * @param string $start Partial string to use as a starting point for the snippet. * @param int $length The target length of the snippet to get. Defaults to 40. * * @return string */ protected function getSnippet($content, $start='', $length=40) { $startPos = 0; if ($start !== '') { $startPos = strpos($content, $start); if ($startPos !== false) { $startPos += strlen($start); } } $snippet = substr($content, $startPos, $length); if ((strlen($content) - $startPos) > $length) { $snippet .= '...'; } return $snippet; }//end getSnippet() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Sniffs/PHP/DisallowAlternativePHPTagsSniff.php0000644000076500000240000002133613614652361031131 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Sniffs\PHP; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class DisallowAlternativePHPTagsSniff implements Sniff { /** * Whether ASP tags are enabled or not. * * @var boolean */ private $aspTags = false; /** * The current PHP version. * * @var integer */ private $phpVersion = null; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { if ($this->phpVersion === null) { $this->phpVersion = Config::getConfigData('php_version'); if ($this->phpVersion === null) { $this->phpVersion = PHP_VERSION_ID; } } if ($this->phpVersion < 70000) { $this->aspTags = (bool) ini_get('asp_tags'); } return [ T_OPEN_TAG, T_OPEN_TAG_WITH_ECHO, T_INLINE_HTML, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $openTag = $tokens[$stackPtr]; $content = $openTag['content']; if (trim($content) === '') { return; } if ($openTag['code'] === T_OPEN_TAG) { if ($content === '<%') { $error = 'ASP style opening tag used; expected "findClosingTag($phpcsFile, $tokens, $stackPtr, '%>'); $errorCode = 'ASPOpenTagFound'; } else if (strpos($content, ''); $errorCode = 'ScriptOpenTagFound'; } if (isset($error, $closer, $errorCode) === true) { $data = [$content]; if ($closer === false) { $phpcsFile->addError($error, $stackPtr, $errorCode, $data); } else { $fix = $phpcsFile->addFixableError($error, $stackPtr, $errorCode, $data); if ($fix === true) { $this->addChangeset($phpcsFile, $tokens, $stackPtr, $closer); } } } return; }//end if if ($openTag['code'] === T_OPEN_TAG_WITH_ECHO && $content === '<%=') { $error = 'ASP style opening tag used with echo; expected "findNext(T_WHITESPACE, ($stackPtr + 1), null, true); $snippet = $this->getSnippet($tokens[$nextVar]['content']); $data = [ $snippet, $content, $snippet, ]; $closer = $this->findClosingTag($phpcsFile, $tokens, $stackPtr, '%>'); if ($closer === false) { $phpcsFile->addError($error, $stackPtr, 'ASPShortOpenTagFound', $data); } else { $fix = $phpcsFile->addFixableError($error, $stackPtr, 'ASPShortOpenTagFound', $data); if ($fix === true) { $this->addChangeset($phpcsFile, $tokens, $stackPtr, $closer, true); } } return; }//end if // Account for incorrect script open tags. if ($openTag['code'] === T_INLINE_HTML && preg_match('`( ././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/DisallowAlternativePHPTagsUnitTest.1.inc.fixedPHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/DisallowAlternativePHPTagsUnitTest.1.inc.fixed0000644000076500000240000000032513614652361032727 0ustar gsherwoodstaff
Some content here.
PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/DisallowAlternativePHPTagsUnitTest.2.inc0000644000076500000240000000030713614652361031632 0ustar gsherwoodstaff
<% echo $var; %>

Some text <% echo $var; %> and some more text

<%= $var . ' and some more text to make sure the snippet works'; %>

Some text <%= $var %> and some more text

././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/DisallowAlternativePHPTagsUnitTest.2.inc.fixedPHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/DisallowAlternativePHPTagsUnitTest.2.inc.fixed0000644000076500000240000000033313614652361032727 0ustar gsherwoodstaff

Some text and some more text

Some text and some more text

PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/DisallowAlternativePHPTagsUnitTest.3.inc0000644000076500000240000000051013614652361031627 0ustar gsherwoodstaff
<% echo $var; %>

Some text <% echo $var; %> and some more text

<%= $var . ' and some more text to make sure the snippet works'; %>

Some text <%= $var %> and some more text

PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/DisallowAlternativePHPTagsUnitTest.php0000644000076500000240000000516313614652361031515 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class DisallowAlternativePHPTagsUnitTest extends AbstractSniffUnitTest { /** * Get a list of all test files to check. * * @param string $testFileBase The base path that the unit tests files will have. * * @return string[] */ protected function getTestFiles($testFileBase) { $testFiles = [$testFileBase.'1.inc']; $aspTags = false; if (PHP_VERSION_ID < 70000) { $aspTags = (bool) ini_get('asp_tags'); } if ($aspTags === true) { $testFiles[] = $testFileBase.'2.inc'; } else { $testFiles[] = $testFileBase.'3.inc'; } return $testFiles; }//end getTestFiles() /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='') { switch ($testFile) { case 'DisallowAlternativePHPTagsUnitTest.1.inc': return [ 4 => 1, 7 => 1, 8 => 1, 11 => 1, ]; case 'DisallowAlternativePHPTagsUnitTest.2.inc': return [ 2 => 1, 3 => 1, 4 => 1, 5 => 1, ]; default: return []; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getWarningList($testFile='') { if ($testFile === 'DisallowAlternativePHPTagsUnitTest.3.inc') { return [ 3 => 1, 4 => 1, 5 => 1, 6 => 1, ]; } return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/DisallowRequestSuperglobalUnitTest.inc0000644000076500000240000000045013614652361031654 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/DisallowRequestSuperglobalUnitTest.php0000644000076500000240000000240113614652361031670 0ustar gsherwoodstaff * @copyright 2006-2019 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class DisallowRequestSuperglobalUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ protected function getErrorList() { return [ 2 => 1, 12 => 1, 13 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ protected function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/DisallowShortOpenTagUnitTest.1.inc0000644000076500000240000000020613614652361030537 0ustar gsherwoodstaff
Some content here. Some content Some more content
PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/DisallowShortOpenTagUnitTest.1.inc.fixed0000644000076500000240000000024313614652361031636 0ustar gsherwoodstaff
Some content here. Some content Some more content
PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/DisallowShortOpenTagUnitTest.2.inc0000644000076500000240000000015613614652361030544 0ustar gsherwoodstaff
Some content Some more content
PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/DisallowShortOpenTagUnitTest.2.inc.fixed0000644000076500000240000000017313614652361031641 0ustar gsherwoodstaff
Some content Some more content
PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/DisallowShortOpenTagUnitTest.3.inc0000644000076500000240000000046313614652361030546 0ustar gsherwoodstaff// Test warning for when short_open_tag is off. Some content Some more content // Test multi-line. Some content Some more content // Make sure skipping works. Some content Some more content // Only recognize closing tag after opener. Some?> content * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class DisallowShortOpenTagUnitTest extends AbstractSniffUnitTest { /** * Get a list of all test files to check. * * @param string $testFileBase The base path that the unit tests files will have. * * @return string[] */ protected function getTestFiles($testFileBase) { $testFiles = [$testFileBase.'1.inc']; $option = (bool) ini_get('short_open_tag'); if ($option === true) { $testFiles[] = $testFileBase.'2.inc'; } else { $testFiles[] = $testFileBase.'3.inc'; } return $testFiles; }//end getTestFiles() /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='') { switch ($testFile) { case 'DisallowShortOpenTagUnitTest.1.inc': return [ 5 => 1, 6 => 1, 7 => 1, 10 => 1, ]; case 'DisallowShortOpenTagUnitTest.2.inc': return [ 2 => 1, 3 => 1, 4 => 1, 7 => 1, ]; default: return []; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getWarningList($testFile='') { switch ($testFile) { case 'DisallowShortOpenTagUnitTest.1.inc': return []; case 'DisallowShortOpenTagUnitTest.3.inc': return [ 3 => 1, 6 => 1, 11 => 1, ]; default: return []; }//end switch }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/DiscourageGotoUnitTest.inc0000644000076500000240000000025713614652361027250 0ustar gsherwoodstaff * @copyright 2006-2017 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class DiscourageGotoUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return []; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return [ 3 => 1, 6 => 1, 11 => 1, 16 => 1, ]; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/ForbiddenFunctionsUnitTest.inc0000644000076500000240000000201613614652361030112 0ustar gsherwoodstaffsizeof($array); $size = $class->count($array); $class->delete($filepath); $class->unset($filepath); function delete() {} function unset() {} function sizeof() {} function count() {} trait DelProvider { public function delete() { //irrelevant } } class LeftSideTest { use DelProvider { delete as protected unsetter; } } class RightSideTest { use DelProvider { delete as delete; } } class RightSideVisTest { use DelProvider { delete as protected delete; DelProvider::delete insteadof delete; } } namespace Something\sizeof; $var = new Sizeof(); class SizeOf implements Something {} function mymodule_form_callback(SizeOf $sizeof) { } ?> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/ForbiddenFunctionsUnitTest.php0000644000076500000240000000240413614652361030131 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ForbiddenFunctionsUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { $errors = [ 2 => 1, 4 => 1, 6 => 1, ]; return $errors; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/LowerCaseConstantUnitTest.inc0000644000076500000240000000233413614652361027726 0ustar gsherwoodstaffNULL = 7; use Zend\Log\Writer\NULL as NullWriter; new \Zend\Log\Writer\NULL(); namespace False; class True extends Null implements False {} use True\Something; use Something\True; class MyClass { public function myFunction() { $var = array('foo' => new True()); } } $x = $f?FALSE:true; $x = $f? FALSE:true; class MyClass { // Spice things up a little. const TRUE = false; } var_dump(MyClass::TRUE); function tRUE() {} $input->getFilterChain()->attachByName('Null', ['type' => Null::TYPE_STRING]); PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/LowerCaseConstantUnitTest.inc.fixed0000644000076500000240000000233413614652361031024 0ustar gsherwoodstaffNULL = 7; use Zend\Log\Writer\NULL as NullWriter; new \Zend\Log\Writer\NULL(); namespace False; class True extends Null implements False {} use True\Something; use Something\True; class MyClass { public function myFunction() { $var = array('foo' => new True()); } } $x = $f?false:true; $x = $f? false:true; class MyClass { // Spice things up a little. const TRUE = false; } var_dump(MyClass::TRUE); function tRUE() {} $input->getFilterChain()->attachByName('Null', ['type' => Null::TYPE_STRING]); PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/LowerCaseConstantUnitTest.js0000644000076500000240000000045413614652361027572 0ustar gsherwoodstaffif (variable === true) { } if (variable === TRUE) { } if (variable === True) { } variable = True; if (variable === false) { } if (variable === FALSE) { } if (variable === False) { } variable = false; if (variable === null) { } if (variable === NULL) { } if (variable === Null) { } variable = NULL; PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/LowerCaseConstantUnitTest.js.fixed0000644000076500000240000000045413614652361030670 0ustar gsherwoodstaffif (variable === true) { } if (variable === true) { } if (variable === true) { } variable = true; if (variable === false) { } if (variable === false) { } if (variable === false) { } variable = false; if (variable === null) { } if (variable === null) { } if (variable === null) { } variable = null; PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/LowerCaseConstantUnitTest.php0000644000076500000240000000413113614652361027741 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class LowerCaseConstantUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='LowerCaseConstantUnitTest.inc') { switch ($testFile) { case 'LowerCaseConstantUnitTest.inc': return [ 7 => 1, 10 => 1, 15 => 1, 16 => 1, 23 => 1, 26 => 1, 31 => 1, 32 => 1, 39 => 1, 42 => 1, 47 => 1, 48 => 1, 70 => 1, 71 => 1, ]; break; case 'LowerCaseConstantUnitTest.js': return [ 2 => 1, 3 => 1, 4 => 1, 7 => 1, 8 => 1, 12 => 1, 13 => 1, 14 => 1, ]; break; default: return []; break; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/LowerCaseKeywordUnitTest.inc0000644000076500000240000000144613614652361027564 0ustar gsherwoodstaff $x; function PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/LowerCaseKeywordUnitTest.inc.fixed0000644000076500000240000000144613614652361030662 0ustar gsherwoodstaff $x; function PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/LowerCaseKeywordUnitTest.php0000644000076500000240000000264413614652361027603 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class LowerCaseKeywordUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 10 => 3, 11 => 4, 12 => 1, 13 => 3, 14 => 7, 15 => 1, 19 => 1, 20 => 1, 21 => 1, 25 => 1, 28 => 1, 31 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/LowerCaseTypeUnitTest.inc0000644000076500000240000000231113614652361027051 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class LowerCaseTypeUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 14 => 1, 15 => 1, 16 => 1, 17 => 1, 18 => 1, 21 => 4, 22 => 3, 23 => 3, 25 => 1, 26 => 2, 27 => 2, 32 => 4, 36 => 1, 37 => 1, 38 => 1, 39 => 1, 43 => 2, 44 => 1, 46 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/NoSilencedErrorsUnitTest.inc0000644000076500000240000000012513614652361027544 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/NoSilencedErrorsUnitTest.php0000644000076500000240000000224513614652361027567 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class NoSilencedErrorsUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return []; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return [5 => 1]; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/RequireStrictTypesUnitTest.1.inc0000644000076500000240000000010713614652361030315 0ustar gsherwoodstaff * @copyright 2006-2019 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class RequireStrictTypesUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='') { switch ($testFile) { case 'RequireStrictTypesUnitTest.1.inc': return []; break; } return [1 => 1]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/SAPIUsageUnitTest.inc0000644000076500000240000000015513614652361026050 0ustar gsherwoodstaffphp_sapi_name() === true) {} PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/SAPIUsageUnitTest.php0000644000076500000240000000222713614652361026070 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class SAPIUsageUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [2 => 1]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/SyntaxUnitTest.inc0000644000076500000240000000002113614652361025605 0ustar gsherwoodstaff * @author Blaine Schmeisser * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class SyntaxUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [3 => 1]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/UpperCaseConstantUnitTest.inc0000644000076500000240000000221313614652361027725 0ustar gsherwoodstaffnull = 7; use Zend\Log\Writer\Null as NullWriter; new \Zend\Log\Writer\Null(); namespace False; class True extends Null implements False {} use True\Something; use Something\True; class MyClass { public function myFunction() { $var = array('foo' => new True()); } } $x = $f?false:TRUE; $x = $f? false:TRUE; class MyClass { // Spice things up a little. const true = FALSE; } var_dump(MyClass::true); function true() {}PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/UpperCaseConstantUnitTest.inc.fixed0000644000076500000240000000221313614652361031023 0ustar gsherwoodstaffnull = 7; use Zend\Log\Writer\Null as NullWriter; new \Zend\Log\Writer\Null(); namespace False; class True extends Null implements False {} use True\Something; use Something\True; class MyClass { public function myFunction() { $var = array('foo' => new True()); } } $x = $f?FALSE:TRUE; $x = $f? FALSE:TRUE; class MyClass { // Spice things up a little. const true = FALSE; } var_dump(MyClass::true); function true() {}PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/PHP/UpperCaseConstantUnitTest.php0000644000076500000240000000272013614652361027746 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class UpperCaseConstantUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 7 => 1, 10 => 1, 15 => 1, 16 => 1, 23 => 1, 26 => 1, 31 => 1, 32 => 1, 39 => 1, 42 => 1, 47 => 1, 48 => 1, 70 => 1, 71 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/Strings/UnnecessaryStringConcatUnitTest.inc0000644000076500000240000000073613614652361032154 0ustar gsherwoodstaff'; $code = '<'.'?php '; $string = 'This is a really long string. ' . 'It is being used for errors. ' . 'The message is not translated.'; ?> PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/Strings/UnnecessaryStringConcatUnitTest.js0000644000076500000240000000063713614652361032017 0ustar gsherwoodstaffvar x = 'My ' + 'string'; var x = 'My ' + 1234; var x = 'My ' + y + ' test'; this.errors['test'] = x; this.errors['test' + 10] = x; this.errors['test' + y] = x; this.errors['test' + 'blah'] = x; this.errors[y] = x; this.errors[y + z] = x; this.errors[y + z + 'My' + 'String'] = x; var long = 'This is a really long string. ' + 'It is being used for errors. ' + 'The message is not translated.'; PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/Strings/UnnecessaryStringConcatUnitTest.php0000644000076500000240000000355413614652361032173 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Tests\Strings; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class UnnecessaryStringConcatUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='UnnecessaryStringConcatUnitTest.inc') { switch ($testFile) { case 'UnnecessaryStringConcatUnitTest.inc': return [ 2 => 1, 6 => 1, 9 => 1, 12 => 1, 19 => 1, 20 => 1, ]; break; case 'UnnecessaryStringConcatUnitTest.js': return [ 1 => 1, 8 => 1, 11 => 1, 14 => 1, 15 => 1, ]; break; default: return []; break; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/VersionControl/GitMergeConflictUnitTest.1.css0000644000076500000240000000140313614652361032226 0ustar gsherwoodstaff/* * This is a CSS comment. <<<<<<< HEAD * This is a merge conflict... ======= * which should be detected. >>>>>>> ref/heads/feature-branch */ .SettingsTabPaneWidgetType-tab-mid { background: transparent url(tab_inact_mid.png) repeat-x; <<<<<<< HEAD line-height: -25px; ======= line-height: -20px; >>>>>>> ref/heads/feature-branch cursor: pointer; -moz-user-select: none; } /* * The above tests are based on "normal" tokens. * The below test checks that once the tokenizer breaks down because of * unexpected merge conflict boundaries, subsequent boundaries will still * be detected correctly. */ /* * This is a CSS comment. <<<<<<< HEAD * This is a merge conflict... ======= * which should be detected. >>>>>>> ref/heads/feature-branch */ PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/VersionControl/GitMergeConflictUnitTest.1.inc0000644000076500000240000000213013614652361032205 0ustar gsherwoodstaff> -1); var_dump( 1 << -1 ); $string = << 'a' <<<<<<< HEAD 'b' => 'b' ======= 'c' => 'c' >>>>>>> master ); } /* * The above tests are based on "normal" tokens. * The below test checks that once the tokenizer breaks down because of * unexpected merge conflict boundaries - i.e. after the first merge conflict * opener in non-comment, non-heredoc/nowdoc, non-inline HTML code -, subsequent * merge conflict boundaries will still be detected correctly. */ /* * Testing detecting subsequent merge conflicts. * <<<<<<< HEAD * @var string $bar */ public function foo($bar){ } /** ============ The above is not the boundary, the below is. ======= * @var string $bar >>>>>>> f19f8a5... Commit message */ // Test that stray boundaries, i.e. an opener without closer and such, are detected. <<<<<<< HEAD $a = 1; ======= PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/VersionControl/GitMergeConflictUnitTest.2.css0000644000076500000240000000141313614652361032230 0ustar gsherwoodstaff/* * This is a CSS comment. <<<<<<< HEAD * This is a merge conflict started in a comment, ending in a CSS block. */ .SettingsTabPaneWidgetType-tab-mid { background: transparent url(tab_inact_mid.png) repeat-x; ======= * which should be detected. **/ .SettingsTabPaneWidgetType-tab-start { line-height: -25px; >>>>>>> ref/heads/feature-branch cursor: pointer; -moz-user-select: none; } /* * The above tests are based on "normal" tokens. * The below test checks that once the tokenizer breaks down because of * unexpected merge conflict boundaries, subsequent boundaries will still * be detected correctly. */ /* * This is a CSS comment. <<<<<<< HEAD * This is a merge conflict... ======= * which should be detected. >>>>>>> ref/heads/feature-branch */ PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/VersionControl/GitMergeConflictUnitTest.2.inc0000644000076500000240000000070113614652361032210 0ustar gsherwoodstaff>>>>>> master */ /* * Testing detecting merge conflicts using different comment styles. * <<<<<<< HEAD * @var string $bar */ public function foo($bar){ } /* ======= * @var string $bar >>>>>>> master */ // Comment <<<<<<< HEAD // Second comment line. NOTE: The above opener breaks the tokenizer. ======= // New second comment line >>>>>>> master // Third comment line PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/VersionControl/GitMergeConflictUnitTest.3.inc0000644000076500000240000000211613614652361032213 0ustar gsherwoodstaff
<<<<<<< HEAD

Testing a merge conflict.

=======

Another text string.

>>>>>>> ref/heads/feature-branch
<<<<<<< HEAD

=======

>>>>>>> ref/heads/feature-branch
>>>>>> master /* * The above tests are based on "normal" tokens. * The below test checks that once the tokenizer breaks down because of * unexpected merge conflict boundaries - i.e. after the first merge conflict * opener in non-comment, non-heredoc/nowdoc, non-inline HTML code -, subsequent * merge conflict boundaries will still be detected correctly. */ ?>
<<<<<<< HEAD

Testing a merge conflict.

=======

Another text string.

>>>>>>> ref/heads/feature-branch
PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/VersionControl/GitMergeConflictUnitTest.4.inc0000644000076500000240000000260413614652361032216 0ustar gsherwoodstaff>>>>>> ref/heads/other-branchname And now they are. EOD; // Heredoc with a merge conflict starter, the closer is outside the heredoc. $string = <<>>>>>> ref/heads/other-branchname // Merge conflict starter outside with a closer inside of the heredoc. // This breaks the tokenizer. <<<<<<< HEAD $string = <<>>>>>> ref/heads/other-branchname EOD; /* * The above tests are based on "normal" tokens. * The below test checks that once the tokenizer breaks down because of * unexpected merge conflict boundaries - i.e. after the first merge conflict * opener in non-comment, non-heredoc/nowdoc, non-inline HTML code -, subsequent * merge conflict boundaries will still be detected correctly. */ $string = <<>>>>>> ref/heads/other-branchname And now they are. EOD; $string = <<>>>>>> ref/heads/other-branchname PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/VersionControl/GitMergeConflictUnitTest.5.inc0000644000076500000240000000134413614652361032217 0ustar gsherwoodstaff>>>>>> ref/heads/other-branchname And now they are. EOD; // Break the tokenizer. <<<<<<< HEAD /* * The above tests are based on "normal" tokens. * The below test checks that once the tokenizer breaks down because of * unexpected merge conflict boundaries - i.e. after the first merge conflict * opener in non-comment, non-heredoc/nowdoc, non-inline HTML code -, subsequent * merge conflict boundaries will still be detected correctly. */ $string = <<<'EOD' can be problematic. <<<<<<< HEAD were previously not detected. ======= should also be detected. >>>>>>> ref/heads/other-branchname And now they are. EOD; PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/VersionControl/GitMergeConflictUnitTest.6.inc0000644000076500000240000000143713614652361032223 0ustar gsherwoodstaff>>>>>> ref/heads/other-branchname And now they are. EOD; // Break the tokenizer. >>>>>>> master /* * The above tests are based on "normal" tokens. * The below test checks that once the tokenizer breaks down because of * unexpected merge conflict boundaries - i.e. after the first merge conflict * opener in non-comment, non-heredoc/nowdoc, non-inline HTML code -, subsequent * merge conflict boundaries will still be detected correctly. */ $string = <<<"EOD" Merge conflicts in PHP 7.3 indented heredocs <<<<<<< HEAD can be problematic. ======= should also be detected. >>>>>>> ref/heads/other-branchname And now they are. EOD; PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/VersionControl/GitMergeConflictUnitTest.js0000644000076500000240000000055513614652361031722 0ustar gsherwoodstaff result = x?y:z; result = x ? y : z; <<<<<<< HEAD if (something === true ======= if (something === false >>>>>>> develop ^ somethingElse === true ) { <<<<<<< HEAD return true; ======= return false; >>>>>>> develop } y = 1 + 2 - 3; /* <<<<<<< HEAD * @var string $bar */ if (something === true /** ======= * @var string $foo >>>>>>> master */ PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/VersionControl/GitMergeConflictUnitTest.php0000644000076500000240000000763413614652361032102 0ustar gsherwoodstaff * @copyright 2017 Juliette Reinders Folmer. All rights reserved. * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Tests\VersionControl; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class GitMergeConflictUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='GitMergeConflictUnitTest.1.inc') { switch ($testFile) { case 'GitMergeConflictUnitTest.1.inc': return [ 26 => 1, 28 => 1, 30 => 1, 45 => 1, 53 => 1, 55 => 1, 59 => 1, 61 => 1, ]; case 'GitMergeConflictUnitTest.2.inc': return [ 4 => 1, 6 => 1, 8 => 1, 14 => 1, 20 => 1, 22 => 1, 26 => 1, 28 => 1, 30 => 1, ]; case 'GitMergeConflictUnitTest.3.inc': return [ 3 => 1, 5 => 1, 7 => 1, 12 => 1, 14 => 1, 16 => 1, 22 => 1, 24 => 1, 26 => 1, 38 => 1, 40 => 1, 42 => 1, ]; case 'GitMergeConflictUnitTest.4.inc': return [ 6 => 1, 8 => 1, 10 => 1, 18 => 1, 22 => 1, 25 => 1, 29 => 1, 34 => 1, 39 => 1, 53 => 1, 55 => 1, 57 => 1, 64 => 1, 68 => 1, 71 => 1, ]; case 'GitMergeConflictUnitTest.5.inc': case 'GitMergeConflictUnitTest.6.inc': return [ 6 => 1, 8 => 1, 10 => 1, 15 => 1, 28 => 1, 30 => 1, 32 => 1, ]; case 'GitMergeConflictUnitTest.1.css': return [ 3 => 1, 5 => 1, 7 => 1, 12 => 1, 14 => 1, 16 => 1, 30 => 1, 32 => 1, 34 => 1, ]; case 'GitMergeConflictUnitTest.2.css': return [ 3 => 1, 8 => 1, 13 => 1, 27 => 1, 29 => 1, 31 => 1, ]; case 'GitMergeConflictUnitTest.js': return [ 5 => 1, 7 => 1, 9 => 1, 12 => 1, 14 => 1, 16 => 1, 24 => 1, 30 => 1, 32 => 1, ]; default: return []; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/VersionControl/SubversionPropertiesUnitTest.inc0000644000076500000240000000013013614652361033073 0ustar gsherwoodstaff * @copyright 2019 Juliette Reinders Folmer. All rights reserved. * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Tests\VersionControl; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class SubversionPropertiesUnitTest extends AbstractSniffUnitTest { /** * Should this test be skipped for some reason. * * @return void */ protected function shouldSkipTest() { // This sniff cannot be tested as no SVN version control directory is available. return true; }//end shouldSkipTest() /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return []; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class ././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/WhiteSpace/ArbitraryParenthesesSpacingUnitTest.incPHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/WhiteSpace/ArbitraryParenthesesSpacingUnitTest.inc0000644000076500000240000000751013614652361033404 0ustar gsherwoodstaff{$var}( $foo,$bar ); $bar(function( $a, $b ) { return function( $c, $d ) use ( $a, $b ) { echo $a, $b, $c, $d; }; })( 'a','b' )( 'c','d' ); $closure( $foo,$bar ); $var = $closure() + $closure( $foo,$bar ) + self::$closure( $foo,$bar ); class Test { public static function baz( $foo, $bar ) { $a = new self( $foo,$bar ); $b = new static( $foo,$bar ); } } /* * Test warning for empty parentheses. */ $a = 4 + (); // Warning. $a = 4 + ( ); // Warning. $a = 4 + (/* Not empty */); /* * Test the actual sniff. */ if ((null !== $extra) && ($row->extra !== $extra)) {} if (( null !== $extra ) && ( $row->extra !== $extra )) {} // Bad x 4. if (( null !== $extra // Bad x 1. && is_int($extra)) && ( $row->extra !== $extra // Bad x 1. || $something ) // Bad x 1. ) {} if (( null !== $extra ) // Bad x 2. && ( $row->extra !== $extra ) // Bad x 2. ) {} $a = (null !== $extra); $a = ( null !== $extra ); // Bad x 2. $sx = $vert ? ($w - 1) : 0; $this->is_overloaded = ( ( ini_get("mbstring.func_overload") & 2 ) != 0 ) && function_exists('mb_substr'); // Bad x 4. $image->flip( ($operation->axis & 1) != 0, ($operation->axis & 2) != 0 ); if ( $success && ('nothumb' == $target || 'all' == $target) ) {} $directory = ('/' == $file[ strlen($file)-1 ]); // phpcs:set Generic.WhiteSpace.ArbitraryParenthesesSpacing spacing 1 if ((null !== $extra) && ($row->extra !== $extra)) {} // Bad x 4. if (( null !== $extra ) && ( $row->extra !== $extra )) {} if (( null !== $extra // Bad x 1. && is_int($extra)) // Bad x 1. && ( $row->extra !== $extra || $something ) // Bad x 1. ) {} if ((null !== $extra) // Bad x 2. && ($row->extra !== $extra) // Bad x 2. ) {} $a = (null !== $extra); // Bad x 2. $a = ( null !== $extra ); $sx = $vert ? ($w - 1) : 0; // Bad x 2. $this->is_overloaded = ((ini_get("mbstring.func_overload") & 2) != 0) && function_exists('mb_substr'); // Bad x 4. $image->flip( ($operation->axis & 1) != 0, ($operation->axis & 2) != 0 ); // Bad x 4. if ( $success && ('nothumb' == $target || 'all' == $target) ) {} // Bad x 2. $directory = ('/' == $file[ strlen($file)-1 ]); // Bad x 2. // phpcs:set Generic.WhiteSpace.ArbitraryParenthesesSpacing spacing 0 /* * Test handling of ignoreNewlines. */ if ( ( null !== $extra ) && ( $row->extra !== $extra ) ) {} // Bad x 4, 1 x line 123, 2 x line 125, 1 x line 127. $a = ( null !== $extra ); // Bad x 2, 1 x line 131, 1 x line 133. // phpcs:set Generic.WhiteSpace.ArbitraryParenthesesSpacing spacing 1 if ( ( null !== $extra ) && ( $row->extra !== $extra ) ) {} // Bad x 4, 1 x line 137, 2 x line 139, 1 x line 141. $a = ( null !== $extra ); // Bad x 2, 1 x line 144, 1 x line 146. // phpcs:set Generic.WhiteSpace.ArbitraryParenthesesSpacing spacing 0 // phpcs:set Generic.WhiteSpace.ArbitraryParenthesesSpacing ignoreNewlines true if ( ( null !== $extra ) && ( $row->extra !== $extra ) ) {} $a = ( null !== $extra ); // phpcs:set Generic.WhiteSpace.ArbitraryParenthesesSpacing ignoreNewlines false ././@LongLink0000000000000000000000000000015200000000000007753 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/WhiteSpace/ArbitraryParenthesesSpacingUnitTest.inc.fixedPHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/WhiteSpace/ArbitraryParenthesesSpacingUnitTest.inc0000644000076500000240000000737213614652361033412 0ustar gsherwoodstaff{$var}( $foo,$bar ); $bar(function( $a, $b ) { return function( $c, $d ) use ( $a, $b ) { echo $a, $b, $c, $d; }; })( 'a','b' )( 'c','d' ); $closure( $foo,$bar ); $var = $closure() + $closure( $foo,$bar ) + self::$closure( $foo,$bar ); class Test { public static function baz( $foo, $bar ) { $a = new self( $foo,$bar ); $b = new static( $foo,$bar ); } } /* * Test warning for empty parentheses. */ $a = 4 + (); // Warning. $a = 4 + ( ); // Warning. $a = 4 + (/* Not empty */); /* * Test the actual sniff. */ if ((null !== $extra) && ($row->extra !== $extra)) {} if ((null !== $extra) && ($row->extra !== $extra)) {} // Bad x 4. if ((null !== $extra // Bad x 1. && is_int($extra)) && ($row->extra !== $extra // Bad x 1. || $something) // Bad x 1. ) {} if ((null !== $extra) // Bad x 2. && ($row->extra !== $extra) // Bad x 2. ) {} $a = (null !== $extra); $a = (null !== $extra); // Bad x 2. $sx = $vert ? ($w - 1) : 0; $this->is_overloaded = ((ini_get("mbstring.func_overload") & 2) != 0) && function_exists('mb_substr'); // Bad x 4. $image->flip( ($operation->axis & 1) != 0, ($operation->axis & 2) != 0 ); if ( $success && ('nothumb' == $target || 'all' == $target) ) {} $directory = ('/' == $file[ strlen($file)-1 ]); // phpcs:set Generic.WhiteSpace.ArbitraryParenthesesSpacing spacing 1 if (( null !== $extra ) && ( $row->extra !== $extra )) {} // Bad x 4. if (( null !== $extra ) && ( $row->extra !== $extra )) {} if (( null !== $extra // Bad x 1. && is_int($extra) ) // Bad x 1. && ( $row->extra !== $extra || $something ) // Bad x 1. ) {} if (( null !== $extra ) // Bad x 2. && ( $row->extra !== $extra ) // Bad x 2. ) {} $a = ( null !== $extra ); // Bad x 2. $a = ( null !== $extra ); $sx = $vert ? ( $w - 1 ) : 0; // Bad x 2. $this->is_overloaded = ( ( ini_get("mbstring.func_overload") & 2 ) != 0 ) && function_exists('mb_substr'); // Bad x 4. $image->flip( ( $operation->axis & 1 ) != 0, ( $operation->axis & 2 ) != 0 ); // Bad x 4. if ( $success && ( 'nothumb' == $target || 'all' == $target ) ) {} // Bad x 2. $directory = ( '/' == $file[ strlen($file)-1 ] ); // Bad x 2. // phpcs:set Generic.WhiteSpace.ArbitraryParenthesesSpacing spacing 0 /* * Test handling of ignoreNewlines. */ if ( (null !== $extra) && ($row->extra !== $extra) ) {} // Bad x 4, 1 x line 123, 2 x line 125, 1 x line 127. $a = (null !== $extra); // Bad x 2, 1 x line 131, 1 x line 133. // phpcs:set Generic.WhiteSpace.ArbitraryParenthesesSpacing spacing 1 if ( ( null !== $extra ) && ( $row->extra !== $extra ) ) {} // Bad x 4, 1 x line 137, 2 x line 139, 1 x line 141. $a = ( null !== $extra ); // Bad x 2, 1 x line 144, 1 x line 146. // phpcs:set Generic.WhiteSpace.ArbitraryParenthesesSpacing spacing 0 // phpcs:set Generic.WhiteSpace.ArbitraryParenthesesSpacing ignoreNewlines true if ( ( null !== $extra ) && ( $row->extra !== $extra ) ) {} $a = ( null !== $extra ); // phpcs:set Generic.WhiteSpace.ArbitraryParenthesesSpacing ignoreNewlines false ././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/WhiteSpace/ArbitraryParenthesesSpacingUnitTest.phpPHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/WhiteSpace/ArbitraryParenthesesSpacingUnitTest.php0000644000076500000240000000361413614652361033423 0ustar gsherwoodstaff * @copyright 2006-2017 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Tests\WhiteSpace; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ArbitraryParenthesesSpacingUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 64 => 4, 66 => 1, 68 => 1, 69 => 1, 72 => 2, 73 => 2, 77 => 2, 81 => 4, 90 => 4, 94 => 1, 95 => 1, 97 => 1, 100 => 2, 101 => 2, 104 => 2, 107 => 2, 109 => 4, 111 => 4, 113 => 2, 115 => 2, 123 => 1, 125 => 2, 127 => 1, 131 => 1, 133 => 1, 137 => 1, 139 => 2, 141 => 1, 144 => 1, 146 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return [ 55 => 1, 56 => 1, ]; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/WhiteSpace/DisallowSpaceIndentUnitTest.css0000644000076500000240000000007513614652361031650 0ustar gsherwoodstaff#login-container { margin-left: -225px; width: 450px; } PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/WhiteSpace/DisallowSpaceIndentUnitTest.css.fixed0000644000076500000240000000007213614652361032743 0ustar gsherwoodstaff#login-container { margin-left: -225px; width: 450px; } PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/WhiteSpace/DisallowSpaceIndentUnitTest.1.inc0000644000076500000240000000424613614652361031774 0ustar gsherwoodstaff"; return "<$name$xmlns$type_str $atts xsi:nil=\"true\"/>"; // [space][space][space][tab]return "<$name$xmlns$type_str $atts xsi:nil=\"true\"/>"; return "<$name$xmlns$type_str $atts xsi:nil=\"true\"/>"; // Doc comments are indent with tabs and one space //[tab]/** //[tab][space]* /** * CVS revision for HTTP headers. * * @var string * @access private */ /** * */ $str = 'hello there'; /** * This PHP DocBlock should be fine, even though there is a single space at the beginning. * * @var int $x */ $x = 1; ?> Foo
"; return "<$name$xmlns$type_str $atts xsi:nil=\"true\"/>"; // [space][space][space][tab]return "<$name$xmlns$type_str $atts xsi:nil=\"true\"/>"; return "<$name$xmlns$type_str $atts xsi:nil=\"true\"/>"; // Doc comments are indent with tabs and one space //[tab]/** //[tab][space]* /** * CVS revision for HTTP headers. * * @var string * @access private */ /** * */ $str = 'hello there'; /** * This PHP DocBlock should be fine, even though there is a single space at the beginning. * * @var int $x */ $x = 1; ?> Foo
"; return "<$name$xmlns$type_str $atts xsi:nil=\"true\"/>"; // [space][space][space][tab]return "<$name$xmlns$type_str $atts xsi:nil=\"true\"/>"; return "<$name$xmlns$type_str $atts xsi:nil=\"true\"/>"; // Doc comments are indent with tabs and one space //[tab]/** //[tab][space]* /** * CVS revision for HTTP headers. * * @var string * @access private */ /** * */ $str = 'hello there'; /** * This PHP DocBlock should be fine, even though there is a single space at the beginning. * * @var int $x */ $x = 1; ?> Foo
"; return "<$name$xmlns$type_str $atts xsi:nil=\"true\"/>"; // [space][space][space][tab]return "<$name$xmlns$type_str $atts xsi:nil=\"true\"/>"; return "<$name$xmlns$type_str $atts xsi:nil=\"true\"/>"; // Doc comments are indent with tabs and one space //[tab]/** //[tab][space]* /** * CVS revision for HTTP headers. * * @var string * @access private */ /** * */ $str = 'hello there'; /** * This PHP DocBlock should be fine, even though there is a single space at the beginning. * * @var int $x */ $x = 1; ?> Foo
* @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Tests\WhiteSpace; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class DisallowSpaceIndentUnitTest extends AbstractSniffUnitTest { /** * Get a list of CLI values to set before the file is tested. * * @param string $testFile The name of the file being tested. * @param \PHP_CodeSniffer\Config $config The config data for the test run. * * @return void */ public function setCliValues($testFile, $config) { if ($testFile === 'DisallowSpaceIndentUnitTest.2.inc') { return; } $config->tabWidth = 4; }//end setCliValues() /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='DisallowSpaceIndentUnitTest.1.inc') { switch ($testFile) { case 'DisallowSpaceIndentUnitTest.1.inc': case 'DisallowSpaceIndentUnitTest.2.inc': return [ 5 => 1, 9 => 1, 15 => 1, 22 => 1, 24 => 1, 30 => 1, 35 => 1, 50 => 1, 55 => 1, 57 => 1, 58 => 1, 59 => 1, 60 => 1, 65 => 1, 66 => 1, 67 => 1, 68 => 1, 69 => 1, 70 => 1, 73 => 1, 77 => 1, 81 => 1, 104 => 1, 105 => 1, 106 => 1, 107 => 1, 108 => 1, 110 => 1, 111 => 1, 112 => 1, 114 => 1, 115 => 1, 117 => 1, 118 => 1, ]; break; case 'DisallowSpaceIndentUnitTest.js': return [3 => 1]; break; case 'DisallowSpaceIndentUnitTest.css': return [2 => 1]; break; default: return []; break; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/WhiteSpace/DisallowTabIndentUnitTest.css0000644000076500000240000000007613614652361031324 0ustar gsherwoodstaff#login-container { margin-left: -225px; width: 450px; } PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/WhiteSpace/DisallowTabIndentUnitTest.css.fixed0000644000076500000240000000010413614652361032412 0ustar gsherwoodstaff#login-container { margin-left: -225px; width: 450px; } PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/WhiteSpace/DisallowTabIndentUnitTest.inc0000644000076500000240000000301113614652361031275 0ustar gsherwoodstaff 'Czech republic', 'România' => 'Romania', 'Magyarország' => 'Hungary', ); $var = "$hello $there"; ?> Foo
'Czech republic', 'România' => 'Romania', 'Magyarország' => 'Hungary', ); $var = "$hello $there"; ?> Foo
* @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Tests\WhiteSpace; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class DisallowTabIndentUnitTest extends AbstractSniffUnitTest { /** * Get a list of CLI values to set before the file is tested. * * @param string $testFile The name of the file being tested. * @param \PHP_CodeSniffer\Config $config The config data for the test run. * * @return void */ public function setCliValues($testFile, $config) { $config->tabWidth = 4; }//end setCliValues() /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='DisallowTabIndentUnitTest.inc') { switch ($testFile) { case 'DisallowTabIndentUnitTest.inc': return [ 5 => 2, 9 => 1, 15 => 1, 20 => 2, 21 => 1, 22 => 2, 23 => 1, 24 => 2, 31 => 1, 32 => 2, 33 => 2, 41 => 1, 42 => 1, 43 => 1, 44 => 1, 45 => 1, 46 => 1, 47 => 1, 48 => 1, 54 => 1, 55 => 1, 56 => 1, 57 => 1, 58 => 1, 59 => 1, 79 => 1, 80 => 1, 81 => 1, 82 => 1, 83 => 1, 85 => 1, 86 => 1, 87 => 1, 89 => 1, 90 => 1, 92 => 1, 93 => 1, ]; break; case 'DisallowTabIndentUnitTest.js': return [ 3 => 1, 5 => 1, 6 => 1, ]; break; case 'DisallowTabIndentUnitTest.css': return [ 1 => 1, 2 => 1, ]; break; default: return []; break; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/WhiteSpace/IncrementDecrementSpacingUnitTest.inc0000644000076500000240000000023213614652361033010 0ustar gsherwoodstaff * @copyright 2018 Juliette Reinders Folmer. All rights reserved. * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Tests\WhiteSpace; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class IncrementDecrementSpacingUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='IncrementDecrementSpacingUnitTest.inc') { switch ($testFile) { case 'IncrementDecrementSpacingUnitTest.inc': case 'IncrementDecrementSpacingUnitTest.js': return [ 5 => 1, 6 => 1, 8 => 1, 10 => 1, 13 => 1, 14 => 1, 16 => 1, 17 => 1, ]; default: return []; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/WhiteSpace/LanguageConstructSpacingUnitTest.inc0000644000076500000240000000240513614652361032671 0ustar gsherwoodstaff * @copyright 2006-2017 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Tests\WhiteSpace; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class LanguageConstructSpacingUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 3 => 1, 7 => 1, 11 => 1, 15 => 1, 19 => 1, 23 => 1, 27 => 1, 30 => 1, 33 => 1, 34 => 1, 35 => 1, 36 => 1, 38 => 1, 44 => 1, 45 => 1, 46 => 2, 49 => 1, 51 => 1, 59 => 1, 61 => 1, 63 => 1, 67 => 1, 70 => 1, 71 => 1, 75 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/WhiteSpace/ScopeIndentUnitTest.1.inc0000644000076500000240000005623213614652361030315 0ustar gsherwoodstaffphpcs:set Generic.WhiteSpace.ScopeIndent tabIndent false hello(); } function hello() { echo 'hello'; }//end hello() function hello2() { if (TRUE) { echo 'hello'; // no error here as its more than 4 spaces. } else { echo 'bye'; } while (TRUE) { echo 'hello'; } do { echo 'hello'; } while (TRUE); } function hello3() { switch ($hello) { case 'hello': break; } } } ?> 


validate()) {
    $safe = $form->getSubmitValues();
}
?>
open(); // error here } public function open() { // Some inline stuff that shouldn't error if (TRUE) echo 'hello'; foreach ($tokens as $token) echo $token; } /** * This is a comment 1. * This is a comment 2. * This is a comment 3. * This is a comment 4. */ public function close() { // All ok. if (TRUE) { if (TRUE) { } else if (FALSE) { foreach ($tokens as $token) { switch ($token) { case '1': case '2': if (true) { if (false) { if (false) { if (false) { echo 'hello'; } } } } break; case '5': break; } do { while (true) { foreach ($tokens as $token) { for ($i = 0; $i < $token; $i++) { echo 'hello'; } } } } while (true); } } } } /* This is another c style comment 1. This is another c style comment 2. This is another c style comment 3. This is another c style comment 4. This is another c style comment 5. */ /* This is a T_COMMENT * * * */ /** This is a T_DOC_COMMENT */ /* This T_COMMENT has a newline in it. */ public function read() { echo 'hello'; // no errors below. $array = array( 'this', 'that' => array( 'hello', 'hello again' => array( 'hello', ), ), ); } } abstract class Test3 { public function parse() { foreach ($t as $ndx => $token) { if (is_array($token)) { echo 'here'; } else { $ts[] = array("token" => $token, "value" => ''); $last = count($ts) - 1; switch ($token) { case '(': if ($last >= 3 && $ts[0]['token'] != T_CLASS && $ts[$last - 2]['token'] == T_OBJECT_OPERATOR && $ts[$last - 3]['token'] == T_VARIABLE ) { if (true) { echo 'hello'; } } array_push($braces, $token); break; } } } } } function test() { $o = << doSomething( function () { echo 123; } ); } } some_function( function() { $a = 403; if ($a === 404) { $a = 403; } } ); some_function( function() { $a = 403; if ($a === 404) { $a = 403; } } ); $myFunction = function() { $a = 403; if ($a === 404) { $a = 403; } }; class Whatever { protected $_protectedArray = array( 'normalString' => 'That email address is already in use!', 'offendingString' => <<<'STRING' Each line of this string is always said to be at column 0, no matter how many spaces are placed at the beginning of each line and the ending STRING on the next line is reported as having to be indented. STRING ); } class MyClass { public static function myFunction() { if (empty($keywords) === FALSE) { $keywords = 'foo'; $existing = 'foo'; } return $keywords; }//end myFunction() }//end class $var = call_user_func( $new_var = function () use (&$a) { if ($a > 0) { return $a++; } else { return $a--; } } ); class AnonymousFn { public function getAnonFn() { return array( 'functions' => Array( 'function1' => function ($a, $b, $c) { $a = $b + $c; $b = $c / 2; return Array($a, $b, $c); }, ), ); } } ?>
"") { $test = true; } else { $test = true; } } ?>

some text

function ($a) { if ($a === true) { echo 'hi'; } } ]; $list = [ 'fn' => function ($a) { if ($a === true) { echo 'hi'; } } ]; if ($foo) { foreach ($bar as $baz) { if ($baz) { ?>
1) { echo '1'; } ?>
1) { echo '1'; } ?>
1) { echo '1'; } ?>
<?= CHtml::encode($this->pageTitle); ?> expects($this->at(2)) ->with($this->callback( function ($subject) { } ) ); /** @var Database $mockedDatabase */ /** @var Container $mockedContainer */ echo $string->append('foo') ->appaend('bar') ->appaend('baz') ->outputUsing( function () { } ); echo PHP_EOL; switch ($arg) { case 1: break; case 2: if ($arg2 == 'foo') { } case 3: default: echo 'default'; } if ($tokens[$stackPtr]['content']{0} === '#') { } else if ($tokens[$stackPtr]['content']{0} === '/' && $tokens[$stackPtr]['content']{1} === '/' ) { } $var = call_user_func( function() { if ($foo) { $new_var = function() { if ($a > 0) { return $a++; } else { return $a--; } }; } } ); a( function() { $a = function() { $b = false; }; true; } ); $var = [ [ '1' => function () { return true; }, ], [ '1' => function () { return true; }, '2' => true, ] ]; if ($foo) { ?>

self::_replaceKeywords($failingComment, $result), 'screenshot' => Test::getScreenshotPath( $projectid, $result['class_name'], ), ); } $this->mockedDatabase ->with( $this->callback( function () { return; } ) ); $this->subject->recordLogin(); function a() { if (true) { static::$a[$b] = static::where($c) ->where($c) ->where( function ($d) { $d->whereNull(); $d->orWhere(); } ) ->first(); if (static::$a[$b] === null) { static::$a[$b] = new static( array( 'a' => $a->id, 'a' => $a->id, ) ); } } return static::$a[$b]; } $foo->load( array( 'bar' => function ($baz) { $baz->call(); } ) ); hello(); $foo = array_unique( array_map( function ($entry) { return $entry * 2; }, array() ) ); bar($foo); class PHP_CodeSniffer_Tokenizers_JS { public $scopeOpeners = array( T_CASE => array( 'end' => array( T_BREAK => T_BREAK, T_RETURN => T_RETURN, ), 'strict' => true, ), ); } echo $string-> append('foo')-> appaend('bar')-> appaend('baz')-> outputUsing( function () { } ); $str = 'the items I want to show are: ' . implode( ', ', array('a', 'b', 'c') ); echo $str; $str = 'foo' . '1' . '2'; echo $str; bar([ 'foo' => foo(function () { return 'foo'; }) ]); $domains = array_unique( array_map( function ($url) { $urlObject = new \Purl\Url($url); return $urlObject->registerableDomain; }, $sites ) ); return $domains; if ($a == 5) : echo "a equals 5"; echo "..."; elseif ($a == 6) : echo "a equals 6"; echo "!!!"; else : echo "a is neither 5 nor 6"; endif; if ($foo): if ($bar) $foo = 1; elseif ($baz) $foo = 2; endif; $this ->method(array( 'foo' => 'bar', ), 'arg', array( 'foo' => 'bar', )); class Foo { use Bar { myMethod as renamedMethod; } } class Foo { use Bar { myMethod as renamedMethod; } } foo(); array( 'key1' => function ($bar) { return $bar; }, 'key2' => function ($foo) { return $foo; }, ); ?> 1, ]; $c = 2; class foo { public function get() { $foo = ['b' => 'c', 'd' => [ ['e' => 'f'] ]]; echo '42'; $foo = array('b' => 'c', 'd' => array( array('e' => 'f') )); echo '42'; } } switch ($foo) { case 1: return array(); case 2: return ''; case 3: return $function(); case 4: return $functionCall($param[0]); case 5: return array() + array(); // Array Merge case 6: // String connect return $functionReturningString('') . $functionReturningString(array()); case 7: return functionCall( $withMultiLineParam[0], array(), $functionReturningString( $withMultiLineParam[1] ) ); case 8: return $param[0][0]; } class Test { public $foo ,$bar ,$baz = [ ] ; public function wtfindent() { } } switch ($x) { case 1: return [1]; default: return [2]; } switch ($foo) { case self::FOO: return $this->bar($gfoo, function ($id) { return FOO::bar($id); }, $values); case self::BAR: $values = $this->bar($foo, $values); break; } $var = array( 'long description' => array(0, 'something'), 'another long description' => array(1, "something else") ); $services = array( 'service 1' => Mockery::mock('class 1') ->shouldReceive('setFilter')->once() ->shouldReceive('getNbResults')->atLeast()->once() ->shouldReceive('getSlice')->once()->andReturn(array()) ->getMock(), 'service 2' => Mockery::mock('class 2') ->shouldReceive('__invoke')->once() ->getMock() ); class Foo { public function setUp() { $this->foo = new class { public $name = 'Some value'; }; } } try { foo(); } catch (\Exception $e) { $foo = function() { return 'foo'; }; if (true) { } } if ($foo) { foo(); } else if ($e) { $foo = function() { return 'foo'; }; if (true) { } } else { $foo = function() { return 'foo'; }; if (true) { } } switch ($parameter) { case null: return [ 'foo' => in_array( 'foo', [] ), ]; default: return []; } class SomeClass { public function someFunc() { a(function () { echo "a"; })->b(function () { echo "b"; }); if (true) { echo "c"; } echo "d"; } } $params = self::validate_parameters(self::read_competency_framework_parameters(), array( 'id' => $id, )); $framework = api::read_framework($params['id']); self::validate_context($framework->get_context()); $output = $PAGE->get_renderer('tool_lp'); class Test123 { protected static $prop1 = [ 'testA' => 123, ], $prop2 = [ 'testB' => 456, ]; protected static $prop3 = array( 'testA' => 123, ), $prop4 = array( 'testB' => 456, ); protected static $prop5; } $foo = foo( function () { $foo->debug( $a, $b ); if ($a) { $b = $a; } } ); if (somethingIsTrue()) { ?>
bar(foo(function () { }), foo(function () { })); echo 'foo'; class Test { public function a() { ?>adebug( $a, $b ); if ($a) { $b = $a; } } ); function test() { $array = []; foreach ($array as $data) { [ 'key1' => $var1, 'key2' => $var2, ] = $data; foreach ($var1 as $method) { echo $method . $var2; } } } switch ($a) { case 0: $a = function () { }; case 1: break; } class Test { public function __construct() { if (false) { echo 0; } } } return [ 'veryLongKeySoIWantToMakeALineBreak' => 'veryLonValueSoIWantToMakeALineBreak', 'someOtherKey' => [ 'someValue' ], 'arrayWithArraysInThere' => [ ['Value1', 'Value1'] ], ]; switch ($sContext) { case 'SOMETHING': case 'CONSTANT': do_something(); break; case 'GLOBAL': case 'GLOBAL1': do_something(); // Fall through default: { do_something(); } } array_map( static function ( $item ) { echo $item; }, $some_array ); /** * Comment. */ $a(function () use ($app) { echo 'hi'; })(); $app->run(); function foo() { $foo('some long description', function () { }); $foo('some long description', function () { }); $foo( 'some long description', function () { }); } switch ( $a ) { case 'a': $b = 2; /** * A comment. */ apply_filter( 'something', $b ); break; case 'aa': $b = 2; /* * A comment. */ apply_filter( 'something', $b ); break; case 'b': $b = 3; ?>
[ ], 'b' => <<<'FOO' foo; FOO ], $a, ]; $query = Model::query() ->when($a, function () { static $b = ''; }); $result = array_map( static fn(int $number) : int => $number + 1, $numbers ); $a = $a === true ? [ 'a' => 1, ] : [ 'a' => 100, ]; ?> "> hello(); } function hello() { echo 'hello'; }//end hello() function hello2() { if (TRUE) { echo 'hello'; // no error here as its more than 4 spaces. } else { echo 'bye'; } while (TRUE) { echo 'hello'; } do { echo 'hello'; } while (TRUE); } function hello3() { switch ($hello) { case 'hello': break; } } } ?> 


validate()) {
    $safe = $form->getSubmitValues();
}
?>
open(); // error here } public function open() { // Some inline stuff that shouldn't error if (TRUE) echo 'hello'; foreach ($tokens as $token) echo $token; } /** * This is a comment 1. * This is a comment 2. * This is a comment 3. * This is a comment 4. */ public function close() { // All ok. if (TRUE) { if (TRUE) { } else if (FALSE) { foreach ($tokens as $token) { switch ($token) { case '1': case '2': if (true) { if (false) { if (false) { if (false) { echo 'hello'; } } } } break; case '5': break; } do { while (true) { foreach ($tokens as $token) { for ($i = 0; $i < $token; $i++) { echo 'hello'; } } } } while (true); } } } } /* This is another c style comment 1. This is another c style comment 2. This is another c style comment 3. This is another c style comment 4. This is another c style comment 5. */ /* This is a T_COMMENT * * * */ /** This is a T_DOC_COMMENT */ /* This T_COMMENT has a newline in it. */ public function read() { echo 'hello'; // no errors below. $array = array( 'this', 'that' => array( 'hello', 'hello again' => array( 'hello', ), ), ); } } abstract class Test3 { public function parse() { foreach ($t as $ndx => $token) { if (is_array($token)) { echo 'here'; } else { $ts[] = array("token" => $token, "value" => ''); $last = count($ts) - 1; switch ($token) { case '(': if ($last >= 3 && $ts[0]['token'] != T_CLASS && $ts[$last - 2]['token'] == T_OBJECT_OPERATOR && $ts[$last - 3]['token'] == T_VARIABLE ) { if (true) { echo 'hello'; } } array_push($braces, $token); break; } } } } } function test() { $o = << doSomething( function () { echo 123; } ); } } some_function( function() { $a = 403; if ($a === 404) { $a = 403; } } ); some_function( function() { $a = 403; if ($a === 404) { $a = 403; } } ); $myFunction = function() { $a = 403; if ($a === 404) { $a = 403; } }; class Whatever { protected $_protectedArray = array( 'normalString' => 'That email address is already in use!', 'offendingString' => <<<'STRING' Each line of this string is always said to be at column 0, no matter how many spaces are placed at the beginning of each line and the ending STRING on the next line is reported as having to be indented. STRING ); } class MyClass { public static function myFunction() { if (empty($keywords) === FALSE) { $keywords = 'foo'; $existing = 'foo'; } return $keywords; }//end myFunction() }//end class $var = call_user_func( $new_var = function () use (&$a) { if ($a > 0) { return $a++; } else { return $a--; } } ); class AnonymousFn { public function getAnonFn() { return array( 'functions' => Array( 'function1' => function ($a, $b, $c) { $a = $b + $c; $b = $c / 2; return Array($a, $b, $c); }, ), ); } } ?>
"") { $test = true; } else { $test = true; } } ?>

some text

function ($a) { if ($a === true) { echo 'hi'; } } ]; $list = [ 'fn' => function ($a) { if ($a === true) { echo 'hi'; } } ]; if ($foo) { foreach ($bar as $baz) { if ($baz) { ?>
1) { echo '1'; } ?>
1) { echo '1'; } ?>
1) { echo '1'; } ?>
<?= CHtml::encode($this->pageTitle); ?> expects($this->at(2)) ->with($this->callback( function ($subject) { } ) ); /** @var Database $mockedDatabase */ /** @var Container $mockedContainer */ echo $string->append('foo') ->appaend('bar') ->appaend('baz') ->outputUsing( function () { } ); echo PHP_EOL; switch ($arg) { case 1: break; case 2: if ($arg2 == 'foo') { } case 3: default: echo 'default'; } if ($tokens[$stackPtr]['content']{0} === '#') { } else if ($tokens[$stackPtr]['content']{0} === '/' && $tokens[$stackPtr]['content']{1} === '/' ) { } $var = call_user_func( function() { if ($foo) { $new_var = function() { if ($a > 0) { return $a++; } else { return $a--; } }; } } ); a( function() { $a = function() { $b = false; }; true; } ); $var = [ [ '1' => function () { return true; }, ], [ '1' => function () { return true; }, '2' => true, ] ]; if ($foo) { ?>

self::_replaceKeywords($failingComment, $result), 'screenshot' => Test::getScreenshotPath( $projectid, $result['class_name'], ), ); } $this->mockedDatabase ->with( $this->callback( function () { return; } ) ); $this->subject->recordLogin(); function a() { if (true) { static::$a[$b] = static::where($c) ->where($c) ->where( function ($d) { $d->whereNull(); $d->orWhere(); } ) ->first(); if (static::$a[$b] === null) { static::$a[$b] = new static( array( 'a' => $a->id, 'a' => $a->id, ) ); } } return static::$a[$b]; } $foo->load( array( 'bar' => function ($baz) { $baz->call(); } ) ); hello(); $foo = array_unique( array_map( function ($entry) { return $entry * 2; }, array() ) ); bar($foo); class PHP_CodeSniffer_Tokenizers_JS { public $scopeOpeners = array( T_CASE => array( 'end' => array( T_BREAK => T_BREAK, T_RETURN => T_RETURN, ), 'strict' => true, ), ); } echo $string-> append('foo')-> appaend('bar')-> appaend('baz')-> outputUsing( function () { } ); $str = 'the items I want to show are: ' . implode( ', ', array('a', 'b', 'c') ); echo $str; $str = 'foo' . '1' . '2'; echo $str; bar([ 'foo' => foo(function () { return 'foo'; }) ]); $domains = array_unique( array_map( function ($url) { $urlObject = new \Purl\Url($url); return $urlObject->registerableDomain; }, $sites ) ); return $domains; if ($a == 5) : echo "a equals 5"; echo "..."; elseif ($a == 6) : echo "a equals 6"; echo "!!!"; else : echo "a is neither 5 nor 6"; endif; if ($foo): if ($bar) $foo = 1; elseif ($baz) $foo = 2; endif; $this ->method(array( 'foo' => 'bar', ), 'arg', array( 'foo' => 'bar', )); class Foo { use Bar { myMethod as renamedMethod; } } class Foo { use Bar { myMethod as renamedMethod; } } foo(); array( 'key1' => function ($bar) { return $bar; }, 'key2' => function ($foo) { return $foo; }, ); ?> 1, ]; $c = 2; class foo { public function get() { $foo = ['b' => 'c', 'd' => [ ['e' => 'f'] ]]; echo '42'; $foo = array('b' => 'c', 'd' => array( array('e' => 'f') )); echo '42'; } } switch ($foo) { case 1: return array(); case 2: return ''; case 3: return $function(); case 4: return $functionCall($param[0]); case 5: return array() + array(); // Array Merge case 6: // String connect return $functionReturningString('') . $functionReturningString(array()); case 7: return functionCall( $withMultiLineParam[0], array(), $functionReturningString( $withMultiLineParam[1] ) ); case 8: return $param[0][0]; } class Test { public $foo ,$bar ,$baz = [ ] ; public function wtfindent() { } } switch ($x) { case 1: return [1]; default: return [2]; } switch ($foo) { case self::FOO: return $this->bar($gfoo, function ($id) { return FOO::bar($id); }, $values); case self::BAR: $values = $this->bar($foo, $values); break; } $var = array( 'long description' => array(0, 'something'), 'another long description' => array(1, "something else") ); $services = array( 'service 1' => Mockery::mock('class 1') ->shouldReceive('setFilter')->once() ->shouldReceive('getNbResults')->atLeast()->once() ->shouldReceive('getSlice')->once()->andReturn(array()) ->getMock(), 'service 2' => Mockery::mock('class 2') ->shouldReceive('__invoke')->once() ->getMock() ); class Foo { public function setUp() { $this->foo = new class { public $name = 'Some value'; }; } } try { foo(); } catch (\Exception $e) { $foo = function() { return 'foo'; }; if (true) { } } if ($foo) { foo(); } else if ($e) { $foo = function() { return 'foo'; }; if (true) { } } else { $foo = function() { return 'foo'; }; if (true) { } } switch ($parameter) { case null: return [ 'foo' => in_array( 'foo', [] ), ]; default: return []; } class SomeClass { public function someFunc() { a(function () { echo "a"; })->b(function () { echo "b"; }); if (true) { echo "c"; } echo "d"; } } $params = self::validate_parameters(self::read_competency_framework_parameters(), array( 'id' => $id, )); $framework = api::read_framework($params['id']); self::validate_context($framework->get_context()); $output = $PAGE->get_renderer('tool_lp'); class Test123 { protected static $prop1 = [ 'testA' => 123, ], $prop2 = [ 'testB' => 456, ]; protected static $prop3 = array( 'testA' => 123, ), $prop4 = array( 'testB' => 456, ); protected static $prop5; } $foo = foo( function () { $foo->debug( $a, $b ); if ($a) { $b = $a; } } ); if (somethingIsTrue()) { ?>
bar(foo(function () { }), foo(function () { })); echo 'foo'; class Test { public function a() { ?>adebug( $a, $b ); if ($a) { $b = $a; } } ); function test() { $array = []; foreach ($array as $data) { [ 'key1' => $var1, 'key2' => $var2, ] = $data; foreach ($var1 as $method) { echo $method . $var2; } } } switch ($a) { case 0: $a = function () { }; case 1: break; } class Test { public function __construct() { if (false) { echo 0; } } } return [ 'veryLongKeySoIWantToMakeALineBreak' => 'veryLonValueSoIWantToMakeALineBreak', 'someOtherKey' => [ 'someValue' ], 'arrayWithArraysInThere' => [ ['Value1', 'Value1'] ], ]; switch ($sContext) { case 'SOMETHING': case 'CONSTANT': do_something(); break; case 'GLOBAL': case 'GLOBAL1': do_something(); // Fall through default: { do_something(); } } array_map( static function ( $item ) { echo $item; }, $some_array ); /** * Comment. */ $a(function () use ($app) { echo 'hi'; })(); $app->run(); function foo() { $foo('some long description', function () { }); $foo('some long description', function () { }); $foo( 'some long description', function () { }); } switch ( $a ) { case 'a': $b = 2; /** * A comment. */ apply_filter( 'something', $b ); break; case 'aa': $b = 2; /* * A comment. */ apply_filter( 'something', $b ); break; case 'b': $b = 3; ?>
[ ], 'b' => <<<'FOO' foo; FOO ], $a, ]; $query = Model::query() ->when($a, function () { static $b = ''; }); $result = array_map( static fn(int $number) : int => $number + 1, $numbers ); $a = $a === true ? [ 'a' => 1, ] : [ 'a' => 100, ]; ?> "> hello(); } function hello() { echo 'hello'; }//end hello() function hello2() { if (TRUE) { echo 'hello'; // no error here as its more than 4 spaces. } else { echo 'bye'; } while (TRUE) { echo 'hello'; } do { echo 'hello'; } while (TRUE); } function hello3() { switch ($hello) { case 'hello': break; } } } ?> 


validate()) {
	$safe = $form->getSubmitValues();
}
?>
open(); // error here } public function open() { // Some inline stuff that shouldn't error if (TRUE) echo 'hello'; foreach ($tokens as $token) echo $token; } /** * This is a comment 1. * This is a comment 2. * This is a comment 3. * This is a comment 4. */ public function close() { // All ok. if (TRUE) { if (TRUE) { } else if (FALSE) { foreach ($tokens as $token) { switch ($token) { case '1': case '2': if (true) { if (false) { if (false) { if (false) { echo 'hello'; } } } } break; case '5': break; } do { while (true) { foreach ($tokens as $token) { for ($i = 0; $i < $token; $i++) { echo 'hello'; } } } } while (true); } } } } /* This is another c style comment 1. This is another c style comment 2. This is another c style comment 3. This is another c style comment 4. This is another c style comment 5. */ /* This is a T_COMMENT * * * */ /** This is a T_DOC_COMMENT */ /* This T_COMMENT has a newline in it. */ public function read() { echo 'hello'; // no errors below. $array = array( 'this', 'that' => array( 'hello', 'hello again' => array( 'hello', ), ), ); } } abstract class Test3 { public function parse() { foreach ($t as $ndx => $token) { if (is_array($token)) { echo 'here'; } else { $ts[] = array("token" => $token, "value" => ''); $last = count($ts) - 1; switch ($token) { case '(': if ($last >= 3 && $ts[0]['token'] != T_CLASS && $ts[$last - 2]['token'] == T_OBJECT_OPERATOR && $ts[$last - 3]['token'] == T_VARIABLE ) { if (true) { echo 'hello'; } } array_push($braces, $token); break; } } } } } function test() { $o = << doSomething( function () { echo 123; } ); } } some_function( function() { $a = 403; if ($a === 404) { $a = 403; } } ); some_function( function() { $a = 403; if ($a === 404) { $a = 403; } } ); $myFunction = function() { $a = 403; if ($a === 404) { $a = 403; } }; class Whatever { protected $_protectedArray = array( 'normalString' => 'That email address is already in use!', 'offendingString' => <<<'STRING' Each line of this string is always said to be at column 0, no matter how many spaces are placed at the beginning of each line and the ending STRING on the next line is reported as having to be indented. STRING ); } class MyClass { public static function myFunction() { if (empty($keywords) === FALSE) { $keywords = 'foo'; $existing = 'foo'; } return $keywords; }//end myFunction() }//end class $var = call_user_func( $new_var = function () use (&$a) { if ($a > 0) { return $a++; } else { return $a--; } } ); class AnonymousFn { public function getAnonFn() { return array( 'functions' => Array( 'function1' => function ($a, $b, $c) { $a = $b + $c; $b = $c / 2; return Array($a, $b, $c); }, ), ); } } ?>
"") { $test = true; } else { $test = true; } } ?>

some text

function ($a) { if ($a === true) { echo 'hi'; } } ]; $list = [ 'fn' => function ($a) { if ($a === true) { echo 'hi'; } } ]; if ($foo) { foreach ($bar as $baz) { if ($baz) { ?>
1) { echo '1'; } ?>
1) { echo '1'; } ?>
1) { echo '1'; } ?>
<?= CHtml::encode($this->pageTitle); ?> expects($this->at(2)) ->with($this->callback( function ($subject) { } ) ); /** @var Database $mockedDatabase */ /** @var Container $mockedContainer */ echo $string->append('foo') ->appaend('bar') ->appaend('baz') ->outputUsing( function () { } ); echo PHP_EOL; switch ($arg) { case 1: break; case 2: if ($arg2 == 'foo') { } case 3: default: echo 'default'; } if ($tokens[$stackPtr]['content']{0} === '#') { } else if ($tokens[$stackPtr]['content']{0} === '/' && $tokens[$stackPtr]['content']{1} === '/' ) { } $var = call_user_func( function() { if ($foo) { $new_var = function() { if ($a > 0) { return $a++; } else { return $a--; } }; } } ); a( function() { $a = function() { $b = false; }; true; } ); $var = [ [ '1' => function () { return true; }, ], [ '1' => function () { return true; }, '2' => true, ] ]; if ($foo) { ?>

self::_replaceKeywords($failingComment, $result), 'screenshot' => Test::getScreenshotPath( $projectid, $result['class_name'], ), ); } $this->mockedDatabase ->with( $this->callback( function () { return; } ) ); $this->subject->recordLogin(); function a() { if (true) { static::$a[$b] = static::where($c) ->where($c) ->where( function ($d) { $d->whereNull(); $d->orWhere(); } ) ->first(); if (static::$a[$b] === null) { static::$a[$b] = new static( array( 'a' => $a->id, 'a' => $a->id, ) ); } } return static::$a[$b]; } $foo->load( array( 'bar' => function ($baz) { $baz->call(); } ) ); hello(); $foo = array_unique( array_map( function ($entry) { return $entry * 2; }, array() ) ); bar($foo); class PHP_CodeSniffer_Tokenizers_JS { public $scopeOpeners = array( T_CASE => array( 'end' => array( T_BREAK => T_BREAK, T_RETURN => T_RETURN, ), 'strict' => true, ), ); } echo $string-> append('foo')-> appaend('bar')-> appaend('baz')-> outputUsing( function () { } ); $str = 'the items I want to show are: ' . implode( ', ', array('a', 'b', 'c') ); echo $str; $str = 'foo' . '1' . '2'; echo $str; bar([ 'foo' => foo(function () { return 'foo'; }) ]); $domains = array_unique( array_map( function ($url) { $urlObject = new \Purl\Url($url); return $urlObject->registerableDomain; }, $sites ) ); return $domains; if ($a == 5) : echo "a equals 5"; echo "..."; elseif ($a == 6) : echo "a equals 6"; echo "!!!"; else : echo "a is neither 5 nor 6"; endif; if ($foo): if ($bar) $foo = 1; elseif ($baz) $foo = 2; endif; $this ->method(array( 'foo' => 'bar', ), 'arg', array( 'foo' => 'bar', )); class Foo { use Bar { myMethod as renamedMethod; } } class Foo { use Bar { myMethod as renamedMethod; } } foo(); array( 'key1' => function ($bar) { return $bar; }, 'key2' => function ($foo) { return $foo; }, ); ?> 1, ]; $c = 2; class foo { public function get() { $foo = ['b' => 'c', 'd' => [ ['e' => 'f'] ]]; echo '42'; $foo = array('b' => 'c', 'd' => array( array('e' => 'f') )); echo '42'; } } switch ($foo) { case 1: return array(); case 2: return ''; case 3: return $function(); case 4: return $functionCall($param[0]); case 5: return array() + array(); // Array Merge case 6: // String connect return $functionReturningString('') . $functionReturningString(array()); case 7: return functionCall( $withMultiLineParam[0], array(), $functionReturningString( $withMultiLineParam[1] ) ); case 8: return $param[0][0]; } class Test { public $foo ,$bar ,$baz = [ ] ; public function wtfindent() { } } switch ($x) { case 1: return [1]; default: return [2]; } switch ($foo) { case self::FOO: return $this->bar($gfoo, function ($id) { return FOO::bar($id); }, $values); case self::BAR: $values = $this->bar($foo, $values); break; } $var = array( 'long description' => array(0, 'something'), 'another long description' => array(1, "something else") ); $services = array( 'service 1' => Mockery::mock('class 1') ->shouldReceive('setFilter')->once() ->shouldReceive('getNbResults')->atLeast()->once() ->shouldReceive('getSlice')->once()->andReturn(array()) ->getMock(), 'service 2' => Mockery::mock('class 2') ->shouldReceive('__invoke')->once() ->getMock() ); class Foo { public function setUp() { $this->foo = new class { public $name = 'Some value'; }; } } try { foo(); } catch (\Exception $e) { $foo = function() { return 'foo'; }; if (true) { } } if ($foo) { foo(); } else if ($e) { $foo = function() { return 'foo'; }; if (true) { } } else { $foo = function() { return 'foo'; }; if (true) { } } switch ($parameter) { case null: return [ 'foo' => in_array( 'foo', [] ), ]; default: return []; } class SomeClass { public function someFunc() { a(function () { echo "a"; })->b(function () { echo "b"; }); if (true) { echo "c"; } echo "d"; } } $params = self::validate_parameters(self::read_competency_framework_parameters(), array( 'id' => $id, )); $framework = api::read_framework($params['id']); self::validate_context($framework->get_context()); $output = $PAGE->get_renderer('tool_lp'); class Test123 { protected static $prop1 = [ 'testA' => 123, ], $prop2 = [ 'testB' => 456, ]; protected static $prop3 = array( 'testA' => 123, ), $prop4 = array( 'testB' => 456, ); protected static $prop5; } $foo = foo( function () { $foo->debug( $a, $b ); if ($a) { $b = $a; } } ); if (somethingIsTrue()) { ?>
bar(foo(function () { }), foo(function () { })); echo 'foo'; class Test { public function a() { ?>adebug( $a, $b ); if ($a) { $b = $a; } } ); function test() { $array = []; foreach ($array as $data) { [ 'key1' => $var1, 'key2' => $var2, ] = $data; foreach ($var1 as $method) { echo $method . $var2; } } } switch ($a) { case 0: $a = function () { }; case 1: break; } class Test { public function __construct() { if (false) { echo 0; } } } return [ 'veryLongKeySoIWantToMakeALineBreak' => 'veryLonValueSoIWantToMakeALineBreak', 'someOtherKey' => [ 'someValue' ], 'arrayWithArraysInThere' => [ ['Value1', 'Value1'] ], ]; switch ($sContext) { case 'SOMETHING': case 'CONSTANT': do_something(); break; case 'GLOBAL': case 'GLOBAL1': do_something(); // Fall through default: { do_something(); } } array_map( static function ( $item ) { echo $item; }, $some_array ); /** * Comment. */ $a(function () use ($app) { echo 'hi'; })(); $app->run(); function foo() { $foo('some long description', function () { }); $foo('some long description', function () { }); $foo( 'some long description', function () { }); } switch ( $a ) { case 'a': $b = 2; /** * A comment. */ apply_filter( 'something', $b ); break; case 'aa': $b = 2; /* * A comment. */ apply_filter( 'something', $b ); break; case 'b': $b = 3; ?>
[ ], 'b' => <<<'FOO' foo; FOO ], $a, ]; $query = Model::query() ->when($a, function () { static $b = ''; }); $result = array_map( static fn(int $number) : int => $number + 1, $numbers ); $a = $a === true ? [ 'a' => 1, ] : [ 'a' => 100, ]; ?> "> hello(); } function hello() { echo 'hello'; }//end hello() function hello2() { if (TRUE) { echo 'hello'; // no error here as its more than 4 spaces. } else { echo 'bye'; } while (TRUE) { echo 'hello'; } do { echo 'hello'; } while (TRUE); } function hello3() { switch ($hello) { case 'hello': break; } } } ?> 


validate()) {
	$safe = $form->getSubmitValues();
}
?>
open(); // error here } public function open() { // Some inline stuff that shouldn't error if (TRUE) echo 'hello'; foreach ($tokens as $token) echo $token; } /** * This is a comment 1. * This is a comment 2. * This is a comment 3. * This is a comment 4. */ public function close() { // All ok. if (TRUE) { if (TRUE) { } else if (FALSE) { foreach ($tokens as $token) { switch ($token) { case '1': case '2': if (true) { if (false) { if (false) { if (false) { echo 'hello'; } } } } break; case '5': break; } do { while (true) { foreach ($tokens as $token) { for ($i = 0; $i < $token; $i++) { echo 'hello'; } } } } while (true); } } } } /* This is another c style comment 1. This is another c style comment 2. This is another c style comment 3. This is another c style comment 4. This is another c style comment 5. */ /* This is a T_COMMENT * * * */ /** This is a T_DOC_COMMENT */ /* This T_COMMENT has a newline in it. */ public function read() { echo 'hello'; // no errors below. $array = array( 'this', 'that' => array( 'hello', 'hello again' => array( 'hello', ), ), ); } } abstract class Test3 { public function parse() { foreach ($t as $ndx => $token) { if (is_array($token)) { echo 'here'; } else { $ts[] = array("token" => $token, "value" => ''); $last = count($ts) - 1; switch ($token) { case '(': if ($last >= 3 && $ts[0]['token'] != T_CLASS && $ts[$last - 2]['token'] == T_OBJECT_OPERATOR && $ts[$last - 3]['token'] == T_VARIABLE ) { if (true) { echo 'hello'; } } array_push($braces, $token); break; } } } } } function test() { $o = << doSomething( function () { echo 123; } ); } } some_function( function() { $a = 403; if ($a === 404) { $a = 403; } } ); some_function( function() { $a = 403; if ($a === 404) { $a = 403; } } ); $myFunction = function() { $a = 403; if ($a === 404) { $a = 403; } }; class Whatever { protected $_protectedArray = array( 'normalString' => 'That email address is already in use!', 'offendingString' => <<<'STRING' Each line of this string is always said to be at column 0, no matter how many spaces are placed at the beginning of each line and the ending STRING on the next line is reported as having to be indented. STRING ); } class MyClass { public static function myFunction() { if (empty($keywords) === FALSE) { $keywords = 'foo'; $existing = 'foo'; } return $keywords; }//end myFunction() }//end class $var = call_user_func( $new_var = function () use (&$a) { if ($a > 0) { return $a++; } else { return $a--; } } ); class AnonymousFn { public function getAnonFn() { return array( 'functions' => Array( 'function1' => function ($a, $b, $c) { $a = $b + $c; $b = $c / 2; return Array($a, $b, $c); }, ), ); } } ?>
"") { $test = true; } else { $test = true; } } ?>

some text

function ($a) { if ($a === true) { echo 'hi'; } } ]; $list = [ 'fn' => function ($a) { if ($a === true) { echo 'hi'; } } ]; if ($foo) { foreach ($bar as $baz) { if ($baz) { ?>
1) { echo '1'; } ?>
1) { echo '1'; } ?>
1) { echo '1'; } ?>
<?= CHtml::encode($this->pageTitle); ?> expects($this->at(2)) ->with($this->callback( function ($subject) { } ) ); /** @var Database $mockedDatabase */ /** @var Container $mockedContainer */ echo $string->append('foo') ->appaend('bar') ->appaend('baz') ->outputUsing( function () { } ); echo PHP_EOL; switch ($arg) { case 1: break; case 2: if ($arg2 == 'foo') { } case 3: default: echo 'default'; } if ($tokens[$stackPtr]['content']{0} === '#') { } else if ($tokens[$stackPtr]['content']{0} === '/' && $tokens[$stackPtr]['content']{1} === '/' ) { } $var = call_user_func( function() { if ($foo) { $new_var = function() { if ($a > 0) { return $a++; } else { return $a--; } }; } } ); a( function() { $a = function() { $b = false; }; true; } ); $var = [ [ '1' => function () { return true; }, ], [ '1' => function () { return true; }, '2' => true, ] ]; if ($foo) { ?>

self::_replaceKeywords($failingComment, $result), 'screenshot' => Test::getScreenshotPath( $projectid, $result['class_name'], ), ); } $this->mockedDatabase ->with( $this->callback( function () { return; } ) ); $this->subject->recordLogin(); function a() { if (true) { static::$a[$b] = static::where($c) ->where($c) ->where( function ($d) { $d->whereNull(); $d->orWhere(); } ) ->first(); if (static::$a[$b] === null) { static::$a[$b] = new static( array( 'a' => $a->id, 'a' => $a->id, ) ); } } return static::$a[$b]; } $foo->load( array( 'bar' => function ($baz) { $baz->call(); } ) ); hello(); $foo = array_unique( array_map( function ($entry) { return $entry * 2; }, array() ) ); bar($foo); class PHP_CodeSniffer_Tokenizers_JS { public $scopeOpeners = array( T_CASE => array( 'end' => array( T_BREAK => T_BREAK, T_RETURN => T_RETURN, ), 'strict' => true, ), ); } echo $string-> append('foo')-> appaend('bar')-> appaend('baz')-> outputUsing( function () { } ); $str = 'the items I want to show are: ' . implode( ', ', array('a', 'b', 'c') ); echo $str; $str = 'foo' . '1' . '2'; echo $str; bar([ 'foo' => foo(function () { return 'foo'; }) ]); $domains = array_unique( array_map( function ($url) { $urlObject = new \Purl\Url($url); return $urlObject->registerableDomain; }, $sites ) ); return $domains; if ($a == 5) : echo "a equals 5"; echo "..."; elseif ($a == 6) : echo "a equals 6"; echo "!!!"; else : echo "a is neither 5 nor 6"; endif; if ($foo): if ($bar) $foo = 1; elseif ($baz) $foo = 2; endif; $this ->method(array( 'foo' => 'bar', ), 'arg', array( 'foo' => 'bar', )); class Foo { use Bar { myMethod as renamedMethod; } } class Foo { use Bar { myMethod as renamedMethod; } } foo(); array( 'key1' => function ($bar) { return $bar; }, 'key2' => function ($foo) { return $foo; }, ); ?> 1, ]; $c = 2; class foo { public function get() { $foo = ['b' => 'c', 'd' => [ ['e' => 'f'] ]]; echo '42'; $foo = array('b' => 'c', 'd' => array( array('e' => 'f') )); echo '42'; } } switch ($foo) { case 1: return array(); case 2: return ''; case 3: return $function(); case 4: return $functionCall($param[0]); case 5: return array() + array(); // Array Merge case 6: // String connect return $functionReturningString('') . $functionReturningString(array()); case 7: return functionCall( $withMultiLineParam[0], array(), $functionReturningString( $withMultiLineParam[1] ) ); case 8: return $param[0][0]; } class Test { public $foo ,$bar ,$baz = [ ] ; public function wtfindent() { } } switch ($x) { case 1: return [1]; default: return [2]; } switch ($foo) { case self::FOO: return $this->bar($gfoo, function ($id) { return FOO::bar($id); }, $values); case self::BAR: $values = $this->bar($foo, $values); break; } $var = array( 'long description' => array(0, 'something'), 'another long description' => array(1, "something else") ); $services = array( 'service 1' => Mockery::mock('class 1') ->shouldReceive('setFilter')->once() ->shouldReceive('getNbResults')->atLeast()->once() ->shouldReceive('getSlice')->once()->andReturn(array()) ->getMock(), 'service 2' => Mockery::mock('class 2') ->shouldReceive('__invoke')->once() ->getMock() ); class Foo { public function setUp() { $this->foo = new class { public $name = 'Some value'; }; } } try { foo(); } catch (\Exception $e) { $foo = function() { return 'foo'; }; if (true) { } } if ($foo) { foo(); } else if ($e) { $foo = function() { return 'foo'; }; if (true) { } } else { $foo = function() { return 'foo'; }; if (true) { } } switch ($parameter) { case null: return [ 'foo' => in_array( 'foo', [] ), ]; default: return []; } class SomeClass { public function someFunc() { a(function () { echo "a"; })->b(function () { echo "b"; }); if (true) { echo "c"; } echo "d"; } } $params = self::validate_parameters(self::read_competency_framework_parameters(), array( 'id' => $id, )); $framework = api::read_framework($params['id']); self::validate_context($framework->get_context()); $output = $PAGE->get_renderer('tool_lp'); class Test123 { protected static $prop1 = [ 'testA' => 123, ], $prop2 = [ 'testB' => 456, ]; protected static $prop3 = array( 'testA' => 123, ), $prop4 = array( 'testB' => 456, ); protected static $prop5; } $foo = foo( function () { $foo->debug( $a, $b ); if ($a) { $b = $a; } } ); if (somethingIsTrue()) { ?>
bar(foo(function () { }), foo(function () { })); echo 'foo'; class Test { public function a() { ?>adebug( $a, $b ); if ($a) { $b = $a; } } ); function test() { $array = []; foreach ($array as $data) { [ 'key1' => $var1, 'key2' => $var2, ] = $data; foreach ($var1 as $method) { echo $method . $var2; } } } switch ($a) { case 0: $a = function () { }; case 1: break; } class Test { public function __construct() { if (false) { echo 0; } } } return [ 'veryLongKeySoIWantToMakeALineBreak' => 'veryLonValueSoIWantToMakeALineBreak', 'someOtherKey' => [ 'someValue' ], 'arrayWithArraysInThere' => [ ['Value1', 'Value1'] ], ]; switch ($sContext) { case 'SOMETHING': case 'CONSTANT': do_something(); break; case 'GLOBAL': case 'GLOBAL1': do_something(); // Fall through default: { do_something(); } } array_map( static function ( $item ) { echo $item; }, $some_array ); /** * Comment. */ $a(function () use ($app) { echo 'hi'; })(); $app->run(); function foo() { $foo('some long description', function () { }); $foo('some long description', function () { }); $foo( 'some long description', function () { }); } switch ( $a ) { case 'a': $b = 2; /** * A comment. */ apply_filter( 'something', $b ); break; case 'aa': $b = 2; /* * A comment. */ apply_filter( 'something', $b ); break; case 'b': $b = 3; ?>
[ ], 'b' => <<<'FOO' foo; FOO ], $a, ]; $query = Model::query() ->when($a, function () { static $b = ''; }); $result = array_map( static fn(int $number) : int => $number + 1, $numbers ); $a = $a === true ? [ 'a' => 1, ] : [ 'a' => 100, ]; ?> $enabled, 'compression' => $compression, ] = $options; } $this->foo() ->bar() ->baz(); PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/WhiteSpace/ScopeIndentUnitTest.3.inc.fixed0000644000076500000240000000071413614652361031407 0ustar gsherwoodstaffphpcs:set Generic.WhiteSpace.ScopeIndent tabIndent false phpcs:set Generic.WhiteSpace.ScopeIndent exact true $enabled, 'compression' => $compression, ] = $options; } $this->foo() ->bar() ->baz(); PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/WhiteSpace/ScopeIndentUnitTest.4.inc0000644000076500000240000000003313614652361030304 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Tests\WhiteSpace; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ScopeIndentUnitTest extends AbstractSniffUnitTest { /** * Get a list of CLI values to set before the file is tested. * * @param string $testFile The name of the file being tested. * @param \PHP_CodeSniffer\Config $config The config data for the test run. * * @return void */ public function setCliValues($testFile, $config) { // Tab width setting is only needed for the tabbed file. if ($testFile === 'ScopeIndentUnitTest.2.inc') { $config->tabWidth = 4; } else { $config->tabWidth = 0; } }//end setCliValues() /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='ScopeIndentUnitTest.inc') { if ($testFile === 'ScopeIndentUnitTest.1.js') { return [ 6 => 1, 14 => 1, 21 => 1, 30 => 1, 32 => 1, 33 => 1, 34 => 1, 39 => 1, 42 => 1, 59 => 1, 60 => 1, 75 => 1, 120 => 1, 121 => 1, 122 => 1, 123 => 1, 141 => 1, 142 => 1, 155 => 1, 156 => 1, 168 => 1, 184 => 1, ]; }//end if if ($testFile === 'ScopeIndentUnitTest.3.inc') { return [ 6 => 1, 7 => 1, 10 => 1, ]; } if ($testFile === 'ScopeIndentUnitTest.4.inc') { return []; } return [ 7 => 1, 10 => 1, 13 => 1, 17 => 1, 20 => 1, 24 => 1, 25 => 1, 27 => 1, 28 => 1, 29 => 1, 30 => 1, 58 => 1, 123 => 1, 224 => 1, 225 => 1, 279 => 1, 280 => 1, 281 => 1, 282 => 1, 283 => 1, 284 => 1, 285 => 1, 286 => 1, 336 => 1, 349 => 1, 380 => 1, 386 => 1, 387 => 1, 388 => 1, 389 => 1, 390 => 1, 397 => 1, 419 => 1, 420 => 1, 465 => 1, 467 => 1, 472 => 1, 473 => 1, 474 => 1, 496 => 1, 498 => 1, 500 => 1, 524 => 1, 526 => 1, 544 => 1, 545 => 1, 546 => 1, 639 => 1, 660 => 1, 662 => 1, 802 => 1, 803 => 1, 823 => 1, 858 => 1, 879 => 1, 1163 => 1, 1197 => 1, 1198 => 1, 1259 => 1, 1264 => 1, 1265 => 1, 1266 => 1, 1269 => 1, 1272 => 1, 1273 => 1, 1274 => 1, 1275 => 1, 1276 => 1, 1277 => 1, 1280 => 1, 1281 => 1, 1282 => 1, 1284 => 1, 1285 => 1, 1288 => 1, 1289 => 1, 1290 => 1, 1292 => 1, 1293 => 1, 1310 => 1, 1312 => 1, 1327 => 1, 1328 => 1, 1329 => 1, 1330 => 1, 1331 => 1, 1332 => 1, 1335 => 1, 1340 => 1, 1342 => 1, 1345 => 1, 1455 => 1, 1456 => 1, 1457 => 1, 1458 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/Tests/WhiteSpace/SpreadOperatorSpacingAfterUnitTest.inc0000644000076500000240000000251413614652361033156 0ustar gsherwoodstaff * @copyright 2019 Juliette Reinders Folmer. All rights reserved. * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Generic\Tests\WhiteSpace; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class SpreadOperatorSpacingAfterUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 12 => 1, 13 => 1, 20 => 2, 40 => 1, 41 => 1, 46 => 2, 60 => 1, 61 => 1, 66 => 2, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Generic/ruleset.xml0000644000076500000240000000043213614652361022606 0ustar gsherwoodstaff A collection of generic sniffs. This standard is not designed to be used to check code. PHP_CodeSniffer-3.5.4/src/Standards/MySource/Sniffs/Channels/DisallowSelfActionsSniff.php0000644000076500000240000001047213614652361031173 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Sniffs\Channels; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Util\Tokens; class DisallowSelfActionsSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_CLASS]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // We are not interested in abstract classes. $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true); if ($prev !== false && $tokens[$prev]['code'] === T_ABSTRACT) { return; } // We are only interested in Action classes. $classNameToken = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); $className = $tokens[$classNameToken]['content']; if (substr($className, -7) !== 'Actions') { return; } $foundFunctions = []; $foundCalls = []; // Find all static method calls in the form self::method() in the class. $classEnd = $tokens[$stackPtr]['scope_closer']; for ($i = ($classNameToken + 1); $i < $classEnd; $i++) { if ($tokens[$i]['code'] !== T_DOUBLE_COLON) { if ($tokens[$i]['code'] === T_FUNCTION) { // Cache the function information. $funcName = $phpcsFile->findNext(T_STRING, ($i + 1)); $funcScope = $phpcsFile->findPrevious(Tokens::$scopeModifiers, ($i - 1)); $foundFunctions[$tokens[$funcName]['content']] = strtolower($tokens[$funcScope]['content']); } continue; } $prevToken = $phpcsFile->findPrevious(T_WHITESPACE, ($i - 1), null, true); if ($tokens[$prevToken]['content'] !== 'self' && $tokens[$prevToken]['content'] !== 'static' ) { continue; } $funcNameToken = $phpcsFile->findNext(T_WHITESPACE, ($i + 1), null, true); if ($tokens[$funcNameToken]['code'] === T_VARIABLE) { // We are only interested in function calls. continue; } $funcName = $tokens[$funcNameToken]['content']; // We've found the function, now we need to find it and see if it is // public, private or protected. If it starts with an underscore we // can assume it is private. if ($funcName[0] === '_') { continue; } $foundCalls[$i] = [ 'name' => $funcName, 'type' => strtolower($tokens[$prevToken]['content']), ]; }//end for $errorClassName = substr($className, 0, -7); foreach ($foundCalls as $token => $funcData) { if (isset($foundFunctions[$funcData['name']]) === false) { // Function was not in this class, might have come from the parent. // Either way, we can't really check this. continue; } else if ($foundFunctions[$funcData['name']] === 'public') { $type = $funcData['type']; $error = "Static calls to public methods in Action classes must not use the $type keyword; use %s::%s() instead"; $data = [ $errorClassName, $funcName, ]; $phpcsFile->addError($error, $token, 'Found'.ucfirst($funcData['type']), $data); } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Sniffs/Channels/IncludeOwnSystemSniff.php0000644000076500000240000000557413614652361030545 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Sniffs\Channels; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Files\File; class IncludeOwnSystemSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_DOUBLE_COLON]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $fileName = $phpcsFile->getFilename(); $matches = []; if (preg_match('|/systems/(.*)/([^/]+)?actions.inc$|i', $fileName, $matches) === 0) { // Not an actions file. return; } $ownClass = $matches[2]; $tokens = $phpcsFile->getTokens(); $typeName = $phpcsFile->findNext(T_CONSTANT_ENCAPSED_STRING, ($stackPtr + 2), null, false, true); $typeName = trim($tokens[$typeName]['content'], " '"); switch (strtolower($tokens[($stackPtr + 1)]['content'])) { case 'includesystem' : $included = strtolower($typeName); break; case 'includeasset' : $included = strtolower($typeName).'assettype'; break; case 'includewidget' : $included = strtolower($typeName).'widgettype'; break; default: return; } if ($included === strtolower($ownClass)) { $error = "You do not need to include \"%s\" from within the system's own actions file"; $data = [$ownClass]; $phpcsFile->addError($error, $stackPtr, 'NotRequired', $data); } }//end process() /** * Determines the included class name from given token. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param array $tokens The array of file tokens. * @param int $stackPtr The position in the tokens array of the * potentially included class. * * @return string */ protected function getIncludedClassFromToken( $phpcsFile, array $tokens, $stackPtr ) { return false; }//end getIncludedClassFromToken() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Sniffs/Channels/IncludeSystemSniff.php0000644000076500000240000003152213614652361030051 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Sniffs\Channels; use PHP_CodeSniffer\Sniffs\AbstractScopeSniff; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Util\Tokens; class IncludeSystemSniff extends AbstractScopeSniff { /** * A list of classes that don't need to be included. * * @var string[] */ private $ignore = [ 'self' => true, 'static' => true, 'parent' => true, 'channels' => true, 'basesystem' => true, 'dal' => true, 'init' => true, 'pdo' => true, 'util' => true, 'ziparchive' => true, 'phpunit_framework_assert' => true, 'abstractmysourceunittest' => true, 'abstractdatacleanunittest' => true, 'exception' => true, 'abstractwidgetwidgettype' => true, 'domdocument' => true, ]; /** * Constructs an AbstractScopeSniff. */ public function __construct() { parent::__construct([T_FUNCTION], [T_DOUBLE_COLON, T_EXTENDS], true); }//end __construct() /** * Processes the function tokens within the class. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param integer $stackPtr The position where the token was found. * @param integer $currScope The current scope opener token. * * @return void */ protected function processTokenWithinScope(File $phpcsFile, $stackPtr, $currScope) { $tokens = $phpcsFile->getTokens(); // Determine the name of the class that the static function // is being called on. $classNameToken = $phpcsFile->findPrevious( T_WHITESPACE, ($stackPtr - 1), null, true ); // Don't process class names represented by variables as this can be // an inexact science. if ($tokens[$classNameToken]['code'] === T_VARIABLE) { return; } $className = $tokens[$classNameToken]['content']; if (isset($this->ignore[strtolower($className)]) === true) { return; } $includedClasses = []; $fileName = strtolower($phpcsFile->getFilename()); $matches = []; if (preg_match('|/systems/(.*)/([^/]+)?actions.inc$|', $fileName, $matches) !== 0) { // This is an actions file, which means we don't // have to include the system in which it exists. $includedClasses[$matches[2]] = true; // Or a system it implements. $class = $phpcsFile->getCondition($stackPtr, T_CLASS); $implements = $phpcsFile->findNext(T_IMPLEMENTS, $class, ($class + 10)); if ($implements !== false) { $implementsClass = $phpcsFile->findNext(T_STRING, $implements); $implementsClassName = strtolower($tokens[$implementsClass]['content']); if (substr($implementsClassName, -7) === 'actions') { $includedClasses[substr($implementsClassName, 0, -7)] = true; } } } // Go searching for includeSystem and includeAsset calls within this // function, or the inclusion of .inc files, which // would be library files. for ($i = ($currScope + 1); $i < $stackPtr; $i++) { $name = $this->getIncludedClassFromToken($phpcsFile, $tokens, $i); if ($name !== false) { $includedClasses[$name] = true; // Special case for Widgets cause they are, well, special. } else if (strtolower($tokens[$i]['content']) === 'includewidget') { $typeName = $phpcsFile->findNext(T_CONSTANT_ENCAPSED_STRING, ($i + 1)); $typeName = trim($tokens[$typeName]['content'], " '"); $includedClasses[strtolower($typeName).'widgettype'] = true; } } // Now go searching for includeSystem, includeAsset or require/include // calls outside our scope. If we are in a class, look outside the // class. If we are not, look outside the function. $condPtr = $currScope; if ($phpcsFile->hasCondition($stackPtr, T_CLASS) === true) { foreach ($tokens[$stackPtr]['conditions'] as $condPtr => $condType) { if ($condType === T_CLASS) { break; } } } for ($i = 0; $i < $condPtr; $i++) { // Skip other scopes. if (isset($tokens[$i]['scope_closer']) === true) { $i = $tokens[$i]['scope_closer']; continue; } $name = $this->getIncludedClassFromToken($phpcsFile, $tokens, $i); if ($name !== false) { $includedClasses[$name] = true; } } // If we are in a testing class, we might have also included // some systems and classes in our setUp() method. $setupFunction = null; if ($phpcsFile->hasCondition($stackPtr, T_CLASS) === true) { foreach ($tokens[$stackPtr]['conditions'] as $condPtr => $condType) { if ($condType === T_CLASS) { // Is this is a testing class? $name = $phpcsFile->findNext(T_STRING, $condPtr); $name = $tokens[$name]['content']; if (substr($name, -8) === 'UnitTest') { // Look for a method called setUp(). $end = $tokens[$condPtr]['scope_closer']; $function = $phpcsFile->findNext(T_FUNCTION, ($condPtr + 1), $end); while ($function !== false) { $name = $phpcsFile->findNext(T_STRING, $function); if ($tokens[$name]['content'] === 'setUp') { $setupFunction = $function; break; } $function = $phpcsFile->findNext(T_FUNCTION, ($function + 1), $end); } } } }//end foreach }//end if if ($setupFunction !== null) { $start = ($tokens[$setupFunction]['scope_opener'] + 1); $end = $tokens[$setupFunction]['scope_closer']; for ($i = $start; $i < $end; $i++) { $name = $this->getIncludedClassFromToken($phpcsFile, $tokens, $i); if ($name !== false) { $includedClasses[$name] = true; } } }//end if if (isset($includedClasses[strtolower($className)]) === false) { $error = 'Static method called on non-included class or system "%s"; include system with Channels::includeSystem() or include class with require_once'; $data = [$className]; $phpcsFile->addError($error, $stackPtr, 'NotIncludedCall', $data); } }//end processTokenWithinScope() /** * Processes a token within the scope that this test is listening to. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * this token was found. * * @return void */ protected function processTokenOutsideScope(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if ($tokens[$stackPtr]['code'] === T_EXTENDS) { // Find the class name. $classNameToken = $phpcsFile->findNext(T_STRING, ($stackPtr + 1)); $className = $tokens[$classNameToken]['content']; } else { // Determine the name of the class that the static function // is being called on. But don't process class names represented by // variables as this can be an inexact science. $classNameToken = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true); if ($tokens[$classNameToken]['code'] === T_VARIABLE) { return; } $className = $tokens[$classNameToken]['content']; } // Some systems are always available. if (isset($this->ignore[strtolower($className)]) === true) { return; } $includedClasses = []; $fileName = strtolower($phpcsFile->getFilename()); $matches = []; if (preg_match('|/systems/([^/]+)/([^/]+)?actions.inc$|', $fileName, $matches) !== 0) { // This is an actions file, which means we don't // have to include the system in which it exists // We know the system from the path. $includedClasses[$matches[1]] = true; } // Go searching for includeSystem, includeAsset or require/include // calls outside our scope. for ($i = 0; $i < $stackPtr; $i++) { // Skip classes and functions as will we never get // into their scopes when including this file, although // we have a chance of getting into IF, WHILE etc. if (($tokens[$i]['code'] === T_CLASS || $tokens[$i]['code'] === T_INTERFACE || $tokens[$i]['code'] === T_FUNCTION) && isset($tokens[$i]['scope_closer']) === true ) { $i = $tokens[$i]['scope_closer']; continue; } $name = $this->getIncludedClassFromToken($phpcsFile, $tokens, $i); if ($name !== false) { $includedClasses[$name] = true; // Special case for Widgets cause they are, well, special. } else if (strtolower($tokens[$i]['content']) === 'includewidget') { $typeName = $phpcsFile->findNext(T_CONSTANT_ENCAPSED_STRING, ($i + 1)); $typeName = trim($tokens[$typeName]['content'], " '"); $includedClasses[strtolower($typeName).'widgettype'] = true; } }//end for if (isset($includedClasses[strtolower($className)]) === false) { if ($tokens[$stackPtr]['code'] === T_EXTENDS) { $error = 'Class extends non-included class or system "%s"; include system with Channels::includeSystem() or include class with require_once'; $data = [$className]; $phpcsFile->addError($error, $stackPtr, 'NotIncludedExtends', $data); } else { $error = 'Static method called on non-included class or system "%s"; include system with Channels::includeSystem() or include class with require_once'; $data = [$className]; $phpcsFile->addError($error, $stackPtr, 'NotIncludedCall', $data); } } }//end processTokenOutsideScope() /** * Determines the included class name from given token. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param array $tokens The array of file tokens. * @param int $stackPtr The position in the tokens array of the * potentially included class. * * @return string */ protected function getIncludedClassFromToken(File $phpcsFile, array $tokens, $stackPtr) { if (strtolower($tokens[$stackPtr]['content']) === 'includesystem') { $systemName = $phpcsFile->findNext(T_CONSTANT_ENCAPSED_STRING, ($stackPtr + 1)); $systemName = trim($tokens[$systemName]['content'], " '"); return strtolower($systemName); } else if (strtolower($tokens[$stackPtr]['content']) === 'includeasset') { $typeName = $phpcsFile->findNext(T_CONSTANT_ENCAPSED_STRING, ($stackPtr + 1)); $typeName = trim($tokens[$typeName]['content'], " '"); return strtolower($typeName).'assettype'; } else if (isset(Tokens::$includeTokens[$tokens[$stackPtr]['code']]) === true) { $filePath = $phpcsFile->findNext(T_CONSTANT_ENCAPSED_STRING, ($stackPtr + 1)); $filePath = $tokens[$filePath]['content']; $filePath = trim($filePath, " '"); $filePath = basename($filePath, '.inc'); return strtolower($filePath); } return false; }//end getIncludedClassFromToken() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Sniffs/Channels/UnusedSystemSniff.php0000644000076500000240000001200713614652361027726 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Sniffs\Channels; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Files\File; class UnusedSystemSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_DOUBLE_COLON]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Check if this is a call to includeSystem, includeAsset or includeWidget. $methodName = strtolower($tokens[($stackPtr + 1)]['content']); if ($methodName === 'includesystem' || $methodName === 'includeasset' || $methodName === 'includewidget' ) { $systemName = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 3), null, true); if ($systemName === false || $tokens[$systemName]['code'] !== T_CONSTANT_ENCAPSED_STRING) { // Must be using a variable instead of a specific system name. // We can't accurately check that. return; } $systemName = trim($tokens[$systemName]['content'], " '"); } else { return; } if ($methodName === 'includeasset') { $systemName .= 'assettype'; } else if ($methodName === 'includewidget') { $systemName .= 'widgettype'; } $systemName = strtolower($systemName); // Now check if this system is used anywhere in this scope. $level = $tokens[$stackPtr]['level']; for ($i = ($stackPtr + 1); $i < $phpcsFile->numTokens; $i++) { if ($tokens[$i]['level'] < $level) { // We have gone out of scope. // If the original include was inside an IF statement that // is checking if the system exists, check the outer scope // as well. if ($tokens[$stackPtr]['level'] === $level) { // We are still in the base level, so this is the first // time we have got here. $conditions = array_keys($tokens[$stackPtr]['conditions']); if (empty($conditions) === false) { $cond = array_pop($conditions); if ($tokens[$cond]['code'] === T_IF) { $i = $tokens[$cond]['scope_closer']; $level--; continue; } } } break; }//end if if ($tokens[$i]['code'] !== T_DOUBLE_COLON && $tokens[$i]['code'] !== T_EXTENDS && $tokens[$i]['code'] !== T_IMPLEMENTS ) { continue; } switch ($tokens[$i]['code']) { case T_DOUBLE_COLON: $usedName = strtolower($tokens[($i - 1)]['content']); if ($usedName === $systemName) { // The included system was used, so it is fine. return; } break; case T_EXTENDS: $classNameToken = $phpcsFile->findNext(T_STRING, ($i + 1)); $className = strtolower($tokens[$classNameToken]['content']); if ($className === $systemName) { // The included system was used, so it is fine. return; } break; case T_IMPLEMENTS: $endImplements = $phpcsFile->findNext([T_EXTENDS, T_OPEN_CURLY_BRACKET], ($i + 1)); for ($x = ($i + 1); $x < $endImplements; $x++) { if ($tokens[$x]['code'] === T_STRING) { $className = strtolower($tokens[$x]['content']); if ($className === $systemName) { // The included system was used, so it is fine. return; } } } break; }//end switch }//end for // If we get to here, the system was not use. $error = 'Included system "%s" is never used'; $data = [$systemName]; $phpcsFile->addError($error, $stackPtr, 'Found', $data); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Sniffs/Commenting/FunctionCommentSniff.php0000644000076500000240000000657513614652361030750 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Sniffs\Commenting; use PHP_CodeSniffer\Standards\Squiz\Sniffs\Commenting\FunctionCommentSniff as SquizFunctionCommentSniff; use PHP_CodeSniffer\Util\Tokens; use PHP_CodeSniffer\Files\File; class FunctionCommentSniff extends SquizFunctionCommentSniff { /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { parent::process($phpcsFile, $stackPtr); $tokens = $phpcsFile->getTokens(); $find = Tokens::$methodPrefixes; $find[] = T_WHITESPACE; $commentEnd = $phpcsFile->findPrevious($find, ($stackPtr - 1), null, true); if ($tokens[$commentEnd]['code'] !== T_DOC_COMMENT_CLOSE_TAG) { return; } $commentStart = $tokens[$commentEnd]['comment_opener']; $hasApiTag = false; foreach ($tokens[$commentStart]['comment_tags'] as $tag) { if ($tokens[$tag]['content'] === '@api') { if ($hasApiTag === true) { // We've come across an API tag already, which means // we were not the first tag in the API list. $error = 'The @api tag must come first in the @api tag list in a function comment'; $phpcsFile->addError($error, $tag, 'ApiNotFirst'); } $hasApiTag = true; // There needs to be a blank line before the @api tag. $prev = $phpcsFile->findPrevious([T_DOC_COMMENT_STRING, T_DOC_COMMENT_TAG], ($tag - 1)); if ($tokens[$prev]['line'] !== ($tokens[$tag]['line'] - 2)) { $error = 'There must be one blank line before the @api tag in a function comment'; $phpcsFile->addError($error, $tag, 'ApiSpacing'); } } else if (substr($tokens[$tag]['content'], 0, 5) === '@api-') { $hasApiTag = true; $prev = $phpcsFile->findPrevious([T_DOC_COMMENT_STRING, T_DOC_COMMENT_TAG], ($tag - 1)); if ($tokens[$prev]['line'] !== ($tokens[$tag]['line'] - 1)) { $error = 'There must be no blank line before the @%s tag in a function comment'; $data = [$tokens[$tag]['content']]; $phpcsFile->addError($error, $tag, 'ApiTagSpacing', $data); } }//end if }//end foreach if ($hasApiTag === true && substr($tokens[$tag]['content'], 0, 4) !== '@api') { // API tags must be the last tags in a function comment. $error = 'The @api tags must be the last tags in a function comment'; $phpcsFile->addError($error, $commentEnd, 'ApiNotLast'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Sniffs/CSS/BrowserSpecificStylesSniff.php0000644000076500000240000000446213614652361030456 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Sniffs\CSS; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Files\File; class BrowserSpecificStylesSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['CSS']; /** * A list of specific stylesheet suffixes we allow. * * These stylesheets contain browser specific styles * so this sniff ignore them files in the form: * *_moz.css and *_ie7.css etc. * * @var array */ protected $specificStylesheets = [ 'moz' => true, 'ie' => true, 'ie7' => true, 'ie8' => true, 'webkit' => true, ]; /** * Returns the token types that this sniff is interested in. * * @return int[] */ public function register() { return [T_STYLE]; }//end register() /** * Processes the tokens that this sniff is interested in. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void */ public function process(File $phpcsFile, $stackPtr) { // Ignore files with browser-specific suffixes. $filename = $phpcsFile->getFilename(); $breakChar = strrpos($filename, '_'); if ($breakChar !== false && substr($filename, -4) === '.css') { $specific = substr($filename, ($breakChar + 1), -4); if (isset($this->specificStylesheets[$specific]) === true) { return; } } $tokens = $phpcsFile->getTokens(); $content = $tokens[$stackPtr]['content']; if ($content[0] === '-') { $error = 'Browser-specific styles are not allowed'; $phpcsFile->addError($error, $stackPtr, 'ForbiddenStyle'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Sniffs/Debug/DebugCodeSniff.php0000644000076500000240000000307613614652361026400 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Sniffs\Debug; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Files\File; class DebugCodeSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_DOUBLE_COLON]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $className = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true); if (strtolower($tokens[$className]['content']) === 'debug') { $method = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); $error = 'Call to debug function Debug::%s() must be removed'; $data = [$tokens[$method]['content']]; $phpcsFile->addError($error, $stackPtr, 'Found', $data); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Sniffs/Debug/FirebugConsoleSniff.php0000644000076500000240000000321213614652361027455 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Sniffs\Debug; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Files\File; class FirebugConsoleSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['JS']; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_STRING, T_PROPERTY, T_LABEL, T_OBJECT, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (strtolower($tokens[$stackPtr]['content']) === 'console') { $error = 'Variables, functions and labels must not be named "console"; name may conflict with Firebug internal variable'; $phpcsFile->addError($error, $stackPtr, 'ConflictFound'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Sniffs/Objects/AssignThisSniff.php0000644000076500000240000000454513614652361027200 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Sniffs\Objects; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Files\File; class AssignThisSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['JS']; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_THIS]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Ignore this.something and other uses of "this" that are not // direct assignments. $next = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($tokens[$next]['code'] !== T_SEMICOLON) { if ($tokens[$next]['line'] === $tokens[$stackPtr]['line']) { return; } } // Something must be assigned to "this". $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true); if ($tokens[$prev]['code'] !== T_EQUAL) { return; } // A variable needs to be assigned to "this". $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($prev - 1), null, true); if ($tokens[$prev]['code'] !== T_STRING) { return; } // We can only assign "this" to a var called "self". if ($tokens[$prev]['content'] !== 'self' && $tokens[$prev]['content'] !== '_self') { $error = 'Keyword "this" can only be assigned to a variable called "self" or "_self"'; $phpcsFile->addError($error, $prev, 'NotSelf'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Sniffs/Objects/CreateWidgetTypeCallbackSniff.php0000644000076500000240000002015213614652361031742 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Sniffs\Objects; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Util\Tokens; class CreateWidgetTypeCallbackSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['JS']; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_OBJECT]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $className = $phpcsFile->findPrevious(T_STRING, ($stackPtr - 1)); if (substr(strtolower($tokens[$className]['content']), -10) !== 'widgettype') { return; } // Search for a create method. $create = $phpcsFile->findNext(T_PROPERTY, $stackPtr, $tokens[$stackPtr]['bracket_closer'], null, 'create'); if ($create === false) { return; } $function = $phpcsFile->findNext([T_WHITESPACE, T_COLON], ($create + 1), null, true); if ($tokens[$function]['code'] !== T_FUNCTION && $tokens[$function]['code'] !== T_CLOSURE ) { return; } $start = ($tokens[$function]['scope_opener'] + 1); $end = ($tokens[$function]['scope_closer'] - 1); // Check that the first argument is called "callback". $arg = $phpcsFile->findNext(T_WHITESPACE, ($tokens[$function]['parenthesis_opener'] + 1), null, true); if ($tokens[$arg]['content'] !== 'callback') { $error = 'The first argument of the create() method of a widget type must be called "callback"'; $phpcsFile->addError($error, $arg, 'FirstArgNotCallback'); } /* Look for return statements within the function. They cannot return anything and must be preceded by the callback.call() line. The callback itself must contain "self" or "this" as the first argument and there needs to be a call to the callback function somewhere in the create method. All calls to the callback function must be followed by a return statement or the end of the method. */ $foundCallback = false; $passedCallback = false; $nestedFunction = null; for ($i = $start; $i <= $end; $i++) { // Keep track of nested functions. if ($nestedFunction !== null) { if ($i === $nestedFunction) { $nestedFunction = null; continue; } } else if (($tokens[$i]['code'] === T_FUNCTION || $tokens[$i]['code'] === T_CLOSURE) && isset($tokens[$i]['scope_closer']) === true ) { $nestedFunction = $tokens[$i]['scope_closer']; continue; } if ($nestedFunction === null && $tokens[$i]['code'] === T_RETURN) { // Make sure return statements are not returning anything. if ($tokens[($i + 1)]['code'] !== T_SEMICOLON) { $error = 'The create() method of a widget type must not return a value'; $phpcsFile->addError($error, $i, 'ReturnValue'); } continue; } else if ($tokens[$i]['code'] !== T_STRING || $tokens[$i]['content'] !== 'callback' ) { continue; } // If this is the form "callback.call(" then it is a call // to the callback function. if ($tokens[($i + 1)]['code'] !== T_OBJECT_OPERATOR || $tokens[($i + 2)]['content'] !== 'call' || $tokens[($i + 3)]['code'] !== T_OPEN_PARENTHESIS ) { // One last chance; this might be the callback function // being passed to another function, like this // "this.init(something, callback, something)". if (isset($tokens[$i]['nested_parenthesis']) === false) { continue; } // Just make sure those brackets don't belong to anyone, // like an IF or FOR statement. foreach ($tokens[$i]['nested_parenthesis'] as $bracket) { if (isset($tokens[$bracket]['parenthesis_owner']) === true) { continue(2); } } // Note that we use this endBracket down further when checking // for a RETURN statement. $nestedParens = $tokens[$i]['nested_parenthesis']; $endBracket = end($nestedParens); $bracket = key($nestedParens); $prev = $phpcsFile->findPrevious( Tokens::$emptyTokens, ($bracket - 1), null, true ); if ($tokens[$prev]['code'] !== T_STRING) { // This is not a function passing the callback. continue; } $passedCallback = true; }//end if $foundCallback = true; if ($passedCallback === false) { // The first argument must be "this" or "self". $arg = $phpcsFile->findNext(T_WHITESPACE, ($i + 4), null, true); if ($tokens[$arg]['content'] !== 'this' && $tokens[$arg]['content'] !== 'self' ) { $error = 'The first argument passed to the callback function must be "this" or "self"'; $phpcsFile->addError($error, $arg, 'FirstArgNotSelf'); } } // Now it must be followed by a return statement or the end of the function. if ($passedCallback === false) { $endBracket = $tokens[($i + 3)]['parenthesis_closer']; } for ($next = $endBracket; $next <= $end; $next++) { // Skip whitespace so we find the next content after the call. if (isset(Tokens::$emptyTokens[$tokens[$next]['code']]) === true) { continue; } // Skip closing braces like END IF because it is not executable code. if ($tokens[$next]['code'] === T_CLOSE_CURLY_BRACKET) { continue; } // We don't care about anything on the current line, like a // semicolon. It doesn't matter if there are other statements on the // line because another sniff will check for those. if ($tokens[$next]['line'] === $tokens[$endBracket]['line']) { continue; } break; } if ($next !== $tokens[$function]['scope_closer'] && $tokens[$next]['code'] !== T_RETURN ) { $error = 'The call to the callback function must be followed by a return statement if it is not the last statement in the create() method'; $phpcsFile->addError($error, $i, 'NoReturn'); } }//end for if ($foundCallback === false) { $error = 'The create() method of a widget type must call the callback function'; $phpcsFile->addError($error, $create, 'CallbackNotCalled'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Sniffs/Objects/DisallowNewWidgetSniff.php0000644000076500000240000000327313614652361030515 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Sniffs\Objects; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Files\File; class DisallowNewWidgetSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_NEW]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $className = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($tokens[$className]['code'] !== T_STRING) { return; } if (substr(strtolower($tokens[$className]['content']), -10) === 'widgettype') { $widgetType = substr($tokens[$className]['content'], 0, -10); $error = 'Manual creation of widget objects is banned; use Widget::getWidget(\'%s\'); instead'; $data = [$widgetType]; $phpcsFile->addError($error, $stackPtr, 'Found', $data); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Sniffs/PHP/AjaxNullComparisonSniff.php0000644000076500000240000000656213614652361027734 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Sniffs\PHP; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Files\File; class AjaxNullComparisonSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_FUNCTION]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Make sure it is an API function. We know this by the doc comment. $commentEnd = $phpcsFile->findPrevious(T_DOC_COMMENT_CLOSE_TAG, $stackPtr); $commentStart = $phpcsFile->findPrevious(T_DOC_COMMENT_OPEN_TAG, ($commentEnd - 1)); // If function doesn't contain any doc comments - skip it. if ($commentEnd === false || $commentStart === false) { return; } $comment = $phpcsFile->getTokensAsString($commentStart, ($commentEnd - $commentStart)); if (strpos($comment, '* @api') === false) { return; } // Find all the vars passed in as we are only interested in comparisons // to NULL for these specific variables. $foundVars = []; $open = $tokens[$stackPtr]['parenthesis_opener']; $close = $tokens[$stackPtr]['parenthesis_closer']; for ($i = ($open + 1); $i < $close; $i++) { if ($tokens[$i]['code'] === T_VARIABLE) { $foundVars[$tokens[$i]['content']] = true; } } if (empty($foundVars) === true) { return; } $start = $tokens[$stackPtr]['scope_opener']; $end = $tokens[$stackPtr]['scope_closer']; for ($i = ($start + 1); $i < $end; $i++) { if ($tokens[$i]['code'] !== T_VARIABLE || isset($foundVars[$tokens[$i]['content']]) === false ) { continue; } $operator = $phpcsFile->findNext(T_WHITESPACE, ($i + 1), null, true); if ($tokens[$operator]['code'] !== T_IS_IDENTICAL && $tokens[$operator]['code'] !== T_IS_NOT_IDENTICAL ) { continue; } $nullValue = $phpcsFile->findNext(T_WHITESPACE, ($operator + 1), null, true); if ($tokens[$nullValue]['code'] !== T_NULL) { continue; } $error = 'Values submitted via Ajax requests should not be compared directly to NULL; use empty() instead'; $phpcsFile->addWarning($error, $nullValue, 'Found'); }//end for }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Sniffs/PHP/EvalObjectFactorySniff.php0000644000076500000240000000744013614652361027525 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Sniffs\PHP; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Util\Tokens; class EvalObjectFactorySniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_EVAL]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); /* We need to find all strings that will be in the eval to determine if the "new" keyword is being used. */ $openBracket = $phpcsFile->findNext(T_OPEN_PARENTHESIS, ($stackPtr + 1)); $closeBracket = $tokens[$openBracket]['parenthesis_closer']; $strings = []; $vars = []; for ($i = ($openBracket + 1); $i < $closeBracket; $i++) { if (isset(Tokens::$stringTokens[$tokens[$i]['code']]) === true) { $strings[$i] = $tokens[$i]['content']; } else if ($tokens[$i]['code'] === T_VARIABLE) { $vars[$i] = $tokens[$i]['content']; } } /* We now have some variables that we need to expand into the strings that were assigned to them, if any. */ foreach ($vars as $varPtr => $varName) { while (($prev = $phpcsFile->findPrevious(T_VARIABLE, ($varPtr - 1))) !== false) { // Make sure this is an assignment of the variable. That means // it will be the first thing on the line. $prevContent = $phpcsFile->findPrevious(T_WHITESPACE, ($prev - 1), null, true); if ($tokens[$prevContent]['line'] === $tokens[$prev]['line']) { $varPtr = $prevContent; continue; } if ($tokens[$prev]['content'] !== $varName) { // This variable has a different name. $varPtr = $prevContent; continue; } // We found one. break; }//end while if ($prev !== false) { // Find all strings on the line. $lineEnd = $phpcsFile->findNext(T_SEMICOLON, ($prev + 1)); for ($i = ($prev + 1); $i < $lineEnd; $i++) { if (isset(Tokens::$stringTokens[$tokens[$i]['code']]) === true) { $strings[$i] = $tokens[$i]['content']; } } } }//end foreach foreach ($strings as $string) { // If the string has "new" in it, it is not allowed. // We don't bother checking if the word "new" is printed to screen // because that is unlikely to happen. We assume the use // of "new" is for object instantiation. if (strstr($string, ' new ') !== false) { $error = 'Do not use eval() to create objects dynamically; use reflection instead'; $phpcsFile->addWarning($error, $stackPtr, 'Found'); } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Sniffs/PHP/GetRequestDataSniff.php0000644000076500000240000000673113614652361027043 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Sniffs\PHP; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Files\File; class GetRequestDataSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_VARIABLE]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $varName = $tokens[$stackPtr]['content']; if ($varName !== '$_REQUEST' && $varName !== '$_GET' && $varName !== '$_POST' && $varName !== '$_FILES' ) { return; } // The only place these super globals can be accessed directly is // in the getRequestData() method of the Security class. $inClass = false; foreach ($tokens[$stackPtr]['conditions'] as $i => $type) { if ($tokens[$i]['code'] === T_CLASS) { $className = $phpcsFile->findNext(T_STRING, $i); $className = $tokens[$className]['content']; if (strtolower($className) === 'security') { $inClass = true; } else { // We don't have nested classes. break; } } else if ($inClass === true && $tokens[$i]['code'] === T_FUNCTION) { $funcName = $phpcsFile->findNext(T_STRING, $i); $funcName = $tokens[$funcName]['content']; if (strtolower($funcName) === 'getrequestdata') { // This is valid. return; } else { // We don't have nested functions. break; } }//end if }//end foreach // If we get to here, the super global was used incorrectly. // First find out how it is being used. $globalName = strtolower(substr($varName, 2)); $usedVar = ''; $openBracket = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($tokens[$openBracket]['code'] === T_OPEN_SQUARE_BRACKET) { $closeBracket = $tokens[$openBracket]['bracket_closer']; $usedVar = $phpcsFile->getTokensAsString(($openBracket + 1), ($closeBracket - $openBracket - 1)); } $type = 'SuperglobalAccessed'; $error = 'The %s super global must not be accessed directly; use Security::getRequestData('; $data = [$varName]; if ($usedVar !== '') { $type .= 'WithVar'; $error .= '%s, \'%s\''; $data[] = $usedVar; $data[] = $globalName; } $error .= ') instead'; $phpcsFile->addError($error, $stackPtr, $type, $data); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Sniffs/PHP/ReturnFunctionValueSniff.php0000644000076500000240000000356713614652361030147 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Sniffs\PHP; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Files\File; class ReturnFunctionValueSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_RETURN]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $functionName = $phpcsFile->findNext(T_STRING, ($stackPtr + 1), null, false, null, true); while ($functionName !== false) { // Check if this is really a function. $bracket = $phpcsFile->findNext(T_WHITESPACE, ($functionName + 1), null, true); if ($tokens[$bracket]['code'] !== T_OPEN_PARENTHESIS) { // Not a function call. $functionName = $phpcsFile->findNext(T_STRING, ($functionName + 1), null, false, null, true); continue; } $error = 'The result of a function call should be assigned to a variable before being returned'; $phpcsFile->addWarning($error, $stackPtr, 'NotAssigned'); break; } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Sniffs/Strings/JoinStringsSniff.php0000644000076500000240000000435613614652361027435 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Sniffs\Strings; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Util\Tokens; class JoinStringsSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['JS']; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_STRING]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param integer $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if ($tokens[$stackPtr]['content'] !== 'join') { return; } $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); if ($tokens[$prev]['code'] !== T_OBJECT_OPERATOR) { return; } $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($prev - 1), null, true); if ($tokens[$prev]['code'] === T_CLOSE_SQUARE_BRACKET) { $opener = $tokens[$prev]['bracket_opener']; if ($tokens[($opener - 1)]['code'] !== T_STRING) { // This means the array is declared inline, like x = [a,b,c].join() // and not elsewhere, like x = y[a].join() // The first is not allowed while the second is. $error = 'Joining strings using inline arrays is not allowed; use the + operator instead'; $phpcsFile->addError($error, $stackPtr, 'ArrayNotAllowed'); } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/Channels/DisallowSelfActionsUnitTest.inc0000644000076500000240000000160013614652361031532 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/Channels/DisallowSelfActionsUnitTest.php0000644000076500000240000000241013614652361031550 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Tests\Channels; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class DisallowSelfActionsUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 12 => 1, 13 => 1, 28 => 1, 29 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/Channels/IncludeSystemUnitTest.inc0000644000076500000240000000556513614652361030427 0ustar gsherwoodstafffetch(PDO::FETCH_NUM) BaseSystem::getDataDir(); Util::getArrayIndex(array(), ''); Channels::includeSystem('Widget'); Widget::includeWidget('AbstractContainer'); class MyWidget extends AbstractContainerWidgetType {} class MyOtherWidget extends BookWidgetType {} $zip = new ZipArchive(); $res = $zip->open($path, ZipArchive::CREATE); class AssetListingUnitTest extends AbstractMySourceUnitTest { function setUp() { parent::setUp(); Channels::includeSystem('MySystem2'); include_once 'Libs/FileSystem.inc'; } function two() { $siteid = MySystem2::getCurrentSiteId(); $parserFiles = FileSystem::listDirectory(); } function three() { $siteid = MySystem3::getCurrentSiteId(); $parserFiles = FileSystem::listDirectory(); } } if (Channels::systemExists('Log') === TRUE) { Channels::includeSystem('Log'); } else { return; } Log::addProjectLog('metadata.field.update', $msg); function two() { Widget::includeWidget('CacheAdminScreen'); $barChart = CacheAdminScreenWidgetType::constructBarchart($data); } $adjustDialog->setOrientation(AbstractWidgetWidgetType::CENTER); $className = 'SquizPerspective'.ucfirst($property['type']).'PropertyType'; Channels::includeSystem($className); $className::setValue($assetid, $propertyid, $perspectives, $value, (array) $property['settings']); ?> PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/Channels/IncludeSystemUnitTest.php0000644000076500000240000000261713614652361030440 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Tests\Channels; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class IncludeSystemUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 9 => 1, 14 => 1, 24 => 1, 27 => 1, 28 => 1, 31 => 1, 36 => 1, 41 => 1, 61 => 1, 70 => 1, 89 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/Channels/UnusedSystemUnitTest.inc0000644000076500000240000000304213614652361030273 0ustar gsherwoodstaffPHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/Channels/UnusedSystemUnitTest.php0000644000076500000240000000244413614652361030316 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Tests\Channels; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class UnusedSystemUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 2 => 1, 5 => 1, 8 => 1, 24 => 1, 34 => 1, 54 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/Commenting/FunctionCommentUnitTest.inc0000644000076500000240000000245413614652361031306 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/Commenting/FunctionCommentUnitTest.php0000644000076500000240000000242713614652361031324 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Tests\Commenting; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class FunctionCommentUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 28 => 1, 36 => 1, 37 => 2, 49 => 1, 58 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/CSS/BrowserSpecificStylesUnitTest.css0000644000076500000240000000043113614652361031033 0ustar gsherwoodstaff.SettingsTabPaneWidgetType-tab-mid { background: transparent url(tab_inact_mid.png) repeat-x; line-height: -25px; cursor: pointer; -moz-user-select: none; } .AssetLineageWidgetType-item { float: left; list-style: none; height: 22px; cursor: pointer; } PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/CSS/BrowserSpecificStylesUnitTest.php0000644000076500000240000000226013614652361031034 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Tests\CSS; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class BrowserSpecificStylesUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [5 => 1]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/Debug/DebugCodeUnitTest.inc0000644000076500000240000000006713614652361026743 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/Debug/DebugCodeUnitTest.php0000644000076500000240000000230513614652361026756 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Tests\Debug; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class DebugCodeUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 2 => 1, 3 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/Debug/FirebugConsoleUnitTest.js0000644000076500000240000000017313614652361027671 0ustar gsherwoodstaffconsole.info(); console.warn(); console.test(); con.sole(); var console = { console: 'string'; }; function console() {}PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/Debug/FirebugConsoleUnitTest.php0000644000076500000240000000275013614652361030047 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Tests\Debug; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class FirebugConsoleUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='FirebugConsoleUnitTest.js') { if ($testFile !== 'FirebugConsoleUnitTest.js') { return []; } return [ 1 => 1, 2 => 1, 3 => 1, 5 => 1, 6 => 1, 8 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/Objects/AssignThisUnitTest.js0000644000076500000240000000044513614652361027404 0ustar gsherwoodstaffvar self = this; buttonWidget.addClickEvent(function() { self.addDynamicSouce(); }); var x = self; var y = this; var test = ''; if (true) { test = this } var itemid = this.items[i].getAttribute('itemid'); for (var x = this; y < 10; y++) { var x = this + 1; } var _self = this;PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/Objects/AssignThisUnitTest.php0000644000076500000240000000264113614652361027557 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Tests\Objects; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class AssignThisUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='AssignThisUnitTest.js') { if ($testFile !== 'AssignThisUnitTest.js') { return []; } return [ 7 => 1, 11 => 1, 16 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/Objects/CreateWidgetTypeCallbackUnitTest.js0000644000076500000240000000573113614652361032161 0ustar gsherwoodstaffSampleWidgetType.prototype = { create: function(callback) { if (x === 1) { return; } if (y === 1) { callback.call(this); // A comment here to explain the return is okay. return; } if (a === 1) { // Cant return value even after calling callback. callback.call(this); return something; } if (a === 1) { // Need to pass self or this to callback function. callback.call(a); } callback.call(self); var self = this; this.createChildren(null, function() { callback.call(self, div); }); // Never good to return a value. return something; callback.call(self); } }; AnotherSampleWidgetType.prototype = { create: function(input) { return; } getSomething: function(input) { return 1; } }; NoCreateWidgetType.prototype = { getSomething: function(input) { return; } }; SomeRandom.prototype = { create: function(input) { return; } }; SampleWidgetType.prototype = { create: function(callback) { if (a === 1) { // This is ok because it is the last statement, // even though it is conditional. callback.call(self); } } }; SampleWidgetType.prototype = { create: function(callback) { var something = callback; } }; SampleWidgetType.prototype = { create: function(callback) { // Also valid because we are passing the callback to // someone else to call. if (y === 1) { this.something(callback); return; } this.init(callback); } }; SampleWidgetType.prototype = { create: function(callback) { // Also valid because we are passing the callback to // someone else to call. if (y === 1) { this.something(callback); } this.init(callback); } }; SampleWidgetType.prototype = { create: function(callback) { if (a === 1) { // This is ok because it is the last statement, // even though it is conditional. this.something(callback); } } }; SampleWidgetType.prototype = { create: function(callback) { if (dfx.isFn(callback) === true) { callback.call(this, cont); return; } } }; SampleWidgetType.prototype = { create: function(callback) { dfx.foreach(items, function(item) { return true; }); if (dfx.isFn(callback) === true) { callback.call(this); } } }; SampleWidgetType.prototype = { create: function(callback) { var self = this; this.createChildren(null, function() { callback.call(self, div); return; }); } };PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/Objects/CreateWidgetTypeCallbackUnitTest.php0000644000076500000240000000274513614652361032336 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Tests\Objects; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class CreateWidgetTypeCallbackUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='CreateWidgetTypeCallbackUnitTest.js') { return [ 18 => 1, 23 => 2, 26 => 1, 30 => 1, 34 => 1, 43 => 2, 91 => 1, 123 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/Objects/DisallowNewWidgetUnitTest.inc0000644000076500000240000000023713614652361031060 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/Objects/DisallowNewWidgetUnitTest.php0000644000076500000240000000225413614652361031077 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Tests\Objects; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class DisallowNewWidgetUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [4 => 1]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/PHP/AjaxNullComparisonUnitTest.inc0000644000076500000240000001352713614652361030301 0ustar gsherwoodstaffgetMessage()); }//end try if ($something === NULL) { if ($bar !== NULL) { } } return $issueid; }//end addIssue() /** * Adds a new issue. * * Returns the new issue id. * * @param string $title Title of the new issue. * @param string $description The description of the issue. * @param string $reporter Asset id of the reporter. * @param integer $projectid Id of the project that the issue belongs to. * @param array $tags Array of tags. * @param string $status The status of the issue. * @param string $assignedTo The asset id of the user that the issue is * assigned to. * @param string $reportedDate If set then this date will be used instead of the * current date and time. * @param integer $reportedMilestone Reported milestone. * * @return integer * @throws ChannelException If there is an error. * */ public static function addIssue( $title, $description, $reporter=NULL, $projectid=NULL, array $tags=array(), $status=NULL, $assignedTo=NULL, $reportedDate=NULL, $reportedMilestone=NULL ) { // Get current projectid if not specified. if ($projectid === NULL) { Channels::includeSystem('Project'); $projectid = Project::getCurrentProjectId(); Channels::modifyBasket('project', $projectid); } }//end addIssue() PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/PHP/AjaxNullComparisonUnitTest.php0000644000076500000240000000246113614652361030312 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class AjaxNullComparisonUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return []; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return [ 41 => 1, 53 => 1, 64 => 1, 77 => 1, 92 => 1, 122 => 1, ]; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/PHP/EvalObjectFactoryUnitTest.inc0000644000076500000240000000061213614652361030065 0ustar gsherwoodstaffPHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/PHP/EvalObjectFactoryUnitTest.php0000644000076500000240000000235213614652361030106 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class EvalObjectFactoryUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return []; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return [ 4 => 1, 12 => 1, 21 => 1, ]; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/PHP/GetRequestDataUnitTest.inc0000644000076500000240000000111013614652361027373 0ustar gsherwoodstaffPHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/PHP/GetRequestDataUnitTest.php0000644000076500000240000000247013614652361027423 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class GetRequestDataUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 2 => 1, 5 => 1, 8 => 1, 21 => 1, 26 => 1, 27 => 1, 28 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/PHP/ReturnFunctionValueUnitTest.inc0000644000076500000240000000025413614652361030503 0ustar gsherwoodstaffmyFunction(); return $obj->variable; return MyClass::VARIABLE; return $variable; return ($var + 1); ?>PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/PHP/ReturnFunctionValueUnitTest.php0000644000076500000240000000235313614652361030523 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ReturnFunctionValueUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return []; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return [ 2 => 1, 3 => 1, 4 => 1, ]; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/Strings/JoinStringsUnitTest.js0000644000076500000240000000073213614652361027640 0ustar gsherwoodstaffone = (1 + 2); two = (one + 2); two = (one + one); three = ('1' + 2); four = ['1', two].join(); four = ['1', two].join(''); four = ['1', [one, two].join(',')].join(' '); four = ['1', [one, two].join()].join(' '); four = ['1', [one, two].join()].join(); five = 'string' + ['1', [one, two].join()].join() + 'string'; six = myArray.join(' '); six = [arrayOne, arrayTwo].join(); // This is fine because the array is not created inline. var x = 'x' + test[x].join('p') + 't';PHP_CodeSniffer-3.5.4/src/Standards/MySource/Tests/Strings/JoinStringsUnitTest.php0000644000076500000240000000277113614652361030020 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\MySource\Tests\Strings; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class JoinStringsUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='JoinStringsUnitTest.js') { if ($testFile !== 'JoinStringsUnitTest.js') { return []; } return [ 6 => 1, 7 => 1, 8 => 2, 9 => 2, 10 => 2, 12 => 2, 15 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/MySource/ruleset.xml0000644000076500000240000000151113614652361022777 0ustar gsherwoodstaff The MySource coding standard builds on the Squiz coding standard. Currently used for MySource Mini development. */Tests/* */Oven/* */data/* */jquery.js */jquery.*.js */viper/* DALConf.inc PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Docs/Classes/ClassDeclarationStandard.xml0000644000076500000240000000101113614652361027451 0ustar gsherwoodstaff { } ]]> { } ]]> PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Docs/Commenting/ClassCommentStandard.xml0000644000076500000240000000627513614652361027352 0ustar gsherwoodstaff /** * The Foo class. */ class Foo { } ]]> /** * The Foo class. */ class Foo { } ]]> /** * The Foo class. */ class Foo { } ]]> /** * The Foo class. */ class Foo { } ]]> The Foo class. */ class Foo { } ]]> The Foo class. */ class Foo { } ]]> * A helper for the Bar class. * * @see Bar */ class Foo { } ]]> * * A helper for the Bar class. * * * @see Bar */ class Foo { } ]]> * @see Bar */ class Foo { } ]]> * * @see Bar */ class Foo { } ]]> Release: 1.0 */ class Foo { } ]]> 1.0 */ class Foo { } ]]> PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Docs/Commenting/FileCommentStandard.xml0000644000076500000240000001470613614652361027162 0ustar gsherwoodstaff /** * Short description here. * * PHP version 5 * * @category Foo * @package Foo_Helpers * @author Marty McFly * @copyright 2013-2014 Foo Inc. * @license MIT License * @link http://example.com */ ]]> ]]> Short description here. * * PHP version 5 * * @category Foo * @package Foo_Helpers * @author Marty McFly * @copyright 2013-2014 Foo Inc. * @license MIT License * @link http://example.com */ ]]> * Short description here. * * PHP version 5 * * @category Foo * @package Foo_Helpers * @author Marty McFly * @copyright 2013-2014 Foo Inc. * @license MIT License * @link http://example.com */ ]]> * PHP version 5 * * @category Foo * @package Foo_Helpers * @author Marty McFly * @copyright 2013-2014 Foo Inc. * @license MIT License * @link http://example.com */ ]]> * * PHP version 5 * * * @category Foo * @package Foo_Helpers * @author Marty McFly * @copyright 2013-2014 Foo Inc. * @license MIT License * @link http://example.com */ ]]> * @category Foo * @package Foo_Helpers * @author Marty McFly * @copyright 2013-2014 Foo Inc. * @license MIT License * @link http://example.com */ ]]> * * @category Foo * @package Foo_Helpers * @author Marty McFly * @copyright 2013-2014 Foo Inc. * @license MIT License * @link http://example.com */ ]]> @category Foo * @package Foo_Helpers * @author Marty McFly * @copyright 2013-2014 Foo Inc. * @license MIT License * @link http://example.com */ ]]> @category Foo * @package Foo_Helpers * @author Marty McFly * @copyright 2013-2014 Foo Inc. * @license MIT License * @link http://example.com */ ]]> @category Foo * @category Bar * @package Foo_Helpers * @author Marty McFly * @copyright 2013-2014 Foo Inc. * @license MIT License * @link http://example.com */ ]]> PHP version 5 * * @category Foo * @package Foo_Helpers * @author Marty McFly * @copyright 2013-2014 Foo Inc. * @license MIT License * @link http://example.com */ ]]> @package Foo_Helpers * @category Foo * @author Marty McFly * @copyright 2013-2014 Foo Inc. * @license MIT License * @link http://example.com */ ]]> * @copyright 2013-2014 Foo Inc. * @license MIT License * @link http://example.com */ ]]> * @copyright 2013-2014 Foo Inc. * @license MIT License * @link http://example.com */ ]]> PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Docs/Commenting/FunctionCommentStandard.xml0000644000076500000240000001102713614652361030061 0ustar gsherwoodstaff /** * Short description here. * * @return void */ function foo() { } ]]> Short description here. * * @return void */ function foo() { } ]]> * Short description here. * * @return void */ function foo() { } ]]> * Long description here. * * @return void */ function foo() { } ]]> * * Long description here. * * * @return void */ function foo() { } ]]> * @return void */ function foo() { } ]]> * * @return void */ function foo() { } ]]> FooException */ function foo() { } ]]> @throws */ function foo() { } ]]> @return void */ function foo() { } ]]> $foo Foo parameter * @param string $bar Bar parameter * @return void */ function foo($foo, $bar) { } ]]> $qux Bar parameter * @return void */ function foo($foo, $bar) { } ]]> $foo Foo parameter * @param string $bar Bar parameter * @return void */ function foo($foo, $bar) { } ]]> $bar Bar parameter * @param string $foo Foo parameter * @return void */ function foo($foo, $bar) { } ]]> PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Docs/Commenting/InlineCommentStandard.xml0000644000076500000240000000066413614652361027517 0ustar gsherwoodstaff // A comment. ]]> # A comment. ]]> PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Docs/ControlStructures/ControlSignatureStandard.xml0000644000076500000240000000171613614652361031703 0ustar gsherwoodstaff ($foo) { } ]]> ($foo){ } ]]> { } ]]> { } ]]> PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Docs/ControlStructures/MultiLineConditionStandard.xml0000644000076500000240000000243013614652361032144 0ustar gsherwoodstaff && $bar ) { } ]]> && $bar ) { } ]]> && $bar ) { } ]]> && $bar ) { } ]]> ) { } ]]> ) { } ]]> PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Docs/Files/IncludingFileStandard.xml0000644000076500000240000000206613614652361026432 0ustar gsherwoodstaff require_once. Anywhere you are conditionally including a class file (for example, factory methods), use include_once. Either of these will ensure that class files are included only once. They share the same file list, so you don't need to worry about mixing them - a file included with require_once will not be included again by include_once. ]]> include_once and require_once are statements, not functions. Parentheses should not surround the subject filename. ]]> ('PHP/CodeSniffer.php'); ]]> PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Docs/Files/LineLengthStandard.xml0000644000076500000240000000031713614652361025744 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Docs/Formatting/MultiLineAssignmentStandard.xml0000644000076500000240000000157613614652361030726 0ustar gsherwoodstaff = $bar; ]]> = $bar; ]]> = $bar; ]]> = $bar; ]]> PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Docs/Functions/FunctionCallSignatureStandard.xml0000644000076500000240000000123513614652361031064 0ustar gsherwoodstaff ( $bar, $baz, $quux ) ; ]]> PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Docs/Functions/FunctionDeclarationStandard.xml0000644000076500000240000000260513614652361030556 0ustar gsherwoodstaff () use ($bar) { }; ]]> ()use($bar){ }; ]]> $bar, $baz ) { }; ]]> $bar, $baz) { }; ]]> PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Docs/Functions/ValidDefaultValueStandard.xml0000644000076500000240000000117313614652361030163 0ustar gsherwoodstaff $persistent = false) { ... } ]]> $persistent = false, $dsn) { ... } ]]> PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Docs/NamingConventions/ValidClassNameStandard.xml0000644000076500000240000000126113614652361031135 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Docs/NamingConventions/ValidFunctionNameStandard.xml0000644000076500000240000000144613614652361031662 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Docs/NamingConventions/ValidVariableNameStandard.xml0000644000076500000240000000141313614652361031614 0ustar gsherwoodstaff publicVar; protected $protectedVar; private $_privateVar; } ]]> _publicVar; protected $_protectedVar; private $privateVar; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Docs/WhiteSpace/ScopeClosingBraceStandard.xml0000644000076500000240000000110113614652361030222 0ustar gsherwoodstaff } ]]> PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Docs/WhiteSpace/ScopeIndentStandard.xml0000644000076500000240000000125213614652361027117 0ustar gsherwoodstaff if ($test) { $var = 1; } } ]]> if ($test) { $var = 1; } } ]]> PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Docs/WhiteSpace/ObjectOperatorIndentStandard.xml0000644000076500000240000000174313614652361030775 0ustar gsherwoodstaff ->bar() ->baz(); ]]> -> bar()-> baz(); ]]> ->bar() ->baz(); ]]> ->bar() ->baz(); ]]> PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Sniffs/Classes/ClassDeclarationSniff.php0000644000076500000240000001300713614652361027315 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Sniffs\Classes; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class ClassDeclarationSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_CLASS, T_INTERFACE, T_TRAIT, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param integer $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $errorData = [strtolower($tokens[$stackPtr]['content'])]; if (isset($tokens[$stackPtr]['scope_opener']) === false) { $error = 'Possible parse error: %s missing opening or closing brace'; $phpcsFile->addWarning($error, $stackPtr, 'MissingBrace', $errorData); return; } $curlyBrace = $tokens[$stackPtr]['scope_opener']; $lastContent = $phpcsFile->findPrevious(T_WHITESPACE, ($curlyBrace - 1), $stackPtr, true); $classLine = $tokens[$lastContent]['line']; $braceLine = $tokens[$curlyBrace]['line']; if ($braceLine === $classLine) { $phpcsFile->recordMetric($stackPtr, 'Class opening brace placement', 'same line'); $error = 'Opening brace of a %s must be on the line after the definition'; $fix = $phpcsFile->addFixableError($error, $curlyBrace, 'OpenBraceNewLine', $errorData); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); if ($tokens[($curlyBrace - 1)]['code'] === T_WHITESPACE) { $phpcsFile->fixer->replaceToken(($curlyBrace - 1), ''); } $phpcsFile->fixer->addNewlineBefore($curlyBrace); $phpcsFile->fixer->endChangeset(); } return; } else { $phpcsFile->recordMetric($stackPtr, 'Class opening brace placement', 'new line'); if ($braceLine > ($classLine + 1)) { $error = 'Opening brace of a %s must be on the line following the %s declaration; found %s line(s)'; $data = [ $tokens[$stackPtr]['content'], $tokens[$stackPtr]['content'], ($braceLine - $classLine - 1), ]; $fix = $phpcsFile->addFixableError($error, $curlyBrace, 'OpenBraceWrongLine', $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($curlyBrace - 1); $i > $lastContent; $i--) { if ($tokens[$i]['line'] === ($tokens[$curlyBrace]['line'] + 1)) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } return; }//end if }//end if if ($tokens[($curlyBrace + 1)]['content'] !== $phpcsFile->eolChar) { $error = 'Opening %s brace must be on a line by itself'; $nextNonWhitespace = $phpcsFile->findNext(T_WHITESPACE, ($curlyBrace + 1), null, true); if ($tokens[$nextNonWhitespace]['code'] === T_PHPCS_IGNORE) { // Don't auto-fix if the next thing is a PHPCS ignore annotation. $phpcsFile->addError($error, $curlyBrace, 'OpenBraceNotAlone', $errorData); } else { $fix = $phpcsFile->addFixableError($error, $curlyBrace, 'OpenBraceNotAlone', $errorData); if ($fix === true) { $phpcsFile->fixer->addNewline($curlyBrace); } } } if ($tokens[($curlyBrace - 1)]['code'] === T_WHITESPACE) { $prevContent = $tokens[($curlyBrace - 1)]['content']; if ($prevContent === $phpcsFile->eolChar) { $spaces = 0; } else { $spaces = $tokens[($curlyBrace - 1)]['length']; } $first = $phpcsFile->findFirstOnLine(T_WHITESPACE, $stackPtr, true); $expected = ($tokens[$first]['column'] - 1); if ($spaces !== $expected) { $error = 'Expected %s spaces before opening brace; %s found'; $data = [ $expected, $spaces, ]; $fix = $phpcsFile->addFixableError($error, $curlyBrace, 'SpaceBeforeBrace', $data); if ($fix === true) { $indent = str_repeat(' ', $expected); if ($spaces === 0) { $phpcsFile->fixer->addContentBefore($curlyBrace, $indent); } else { $phpcsFile->fixer->replaceToken(($curlyBrace - 1), $indent); } } } }//end if }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Sniffs/Commenting/ClassCommentSniff.php0000644000076500000240000000625413614652361027203 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Sniffs\Commenting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Util\Tokens; class ClassCommentSniff extends FileCommentSniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_CLASS, T_INTERFACE, T_TRAIT, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $type = strtolower($tokens[$stackPtr]['content']); $errorData = [$type]; $find = Tokens::$methodPrefixes; $find[] = T_WHITESPACE; $commentEnd = $phpcsFile->findPrevious($find, ($stackPtr - 1), null, true); if ($tokens[$commentEnd]['code'] !== T_DOC_COMMENT_CLOSE_TAG && $tokens[$commentEnd]['code'] !== T_COMMENT ) { $errorData[] = $phpcsFile->getDeclarationName($stackPtr); $phpcsFile->addError('Missing doc comment for %s %s', $stackPtr, 'Missing', $errorData); $phpcsFile->recordMetric($stackPtr, 'Class has doc comment', 'no'); return; } $phpcsFile->recordMetric($stackPtr, 'Class has doc comment', 'yes'); if ($tokens[$commentEnd]['code'] === T_COMMENT) { $phpcsFile->addError('You must use "/**" style comments for a %s comment', $stackPtr, 'WrongStyle', $errorData); return; } // Check each tag. $this->processTags($phpcsFile, $stackPtr, $tokens[$commentEnd]['comment_opener']); }//end process() /** * Process the version tag. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param array $tags The tokens for these tags. * * @return void */ protected function processVersion($phpcsFile, array $tags) { $tokens = $phpcsFile->getTokens(); foreach ($tags as $tag) { if ($tokens[($tag + 2)]['code'] !== T_DOC_COMMENT_STRING) { // No content. continue; } $content = $tokens[($tag + 2)]['content']; if ((strstr($content, 'Release:') === false)) { $error = 'Invalid version "%s" in doc comment; consider "Release: " instead'; $data = [$content]; $phpcsFile->addWarning($error, $tag, 'InvalidVersion', $data); } } }//end processVersion() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Sniffs/Commenting/FileCommentSniff.php0000644000076500000240000004626713614652361027025 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Sniffs\Commenting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Common; class FileCommentSniff implements Sniff { /** * Tags in correct order and related info. * * @var array */ protected $tags = [ '@category' => [ 'required' => true, 'allow_multiple' => false, ], '@package' => [ 'required' => true, 'allow_multiple' => false, ], '@subpackage' => [ 'required' => false, 'allow_multiple' => false, ], '@author' => [ 'required' => true, 'allow_multiple' => true, ], '@copyright' => [ 'required' => false, 'allow_multiple' => true, ], '@license' => [ 'required' => true, 'allow_multiple' => false, ], '@version' => [ 'required' => false, 'allow_multiple' => false, ], '@link' => [ 'required' => true, 'allow_multiple' => true, ], '@see' => [ 'required' => false, 'allow_multiple' => true, ], '@since' => [ 'required' => false, 'allow_multiple' => false, ], '@deprecated' => [ 'required' => false, 'allow_multiple' => false, ], ]; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return int */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Find the next non whitespace token. $commentStart = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); // Allow declare() statements at the top of the file. if ($tokens[$commentStart]['code'] === T_DECLARE) { $semicolon = $phpcsFile->findNext(T_SEMICOLON, ($commentStart + 1)); $commentStart = $phpcsFile->findNext(T_WHITESPACE, ($semicolon + 1), null, true); } // Ignore vim header. if ($tokens[$commentStart]['code'] === T_COMMENT) { if (strstr($tokens[$commentStart]['content'], 'vim:') !== false) { $commentStart = $phpcsFile->findNext( T_WHITESPACE, ($commentStart + 1), null, true ); } } $errorToken = ($stackPtr + 1); if (isset($tokens[$errorToken]) === false) { $errorToken--; } if ($tokens[$commentStart]['code'] === T_CLOSE_TAG) { // We are only interested if this is the first open tag. return ($phpcsFile->numTokens + 1); } else if ($tokens[$commentStart]['code'] === T_COMMENT) { $error = 'You must use "/**" style comments for a file comment'; $phpcsFile->addError($error, $errorToken, 'WrongStyle'); $phpcsFile->recordMetric($stackPtr, 'File has doc comment', 'yes'); return ($phpcsFile->numTokens + 1); } else if ($commentStart === false || $tokens[$commentStart]['code'] !== T_DOC_COMMENT_OPEN_TAG ) { $phpcsFile->addError('Missing file doc comment', $errorToken, 'Missing'); $phpcsFile->recordMetric($stackPtr, 'File has doc comment', 'no'); return ($phpcsFile->numTokens + 1); } $commentEnd = $tokens[$commentStart]['comment_closer']; $nextToken = $phpcsFile->findNext( T_WHITESPACE, ($commentEnd + 1), null, true ); $ignore = [ T_CLASS, T_INTERFACE, T_TRAIT, T_FUNCTION, T_CLOSURE, T_PUBLIC, T_PRIVATE, T_PROTECTED, T_FINAL, T_STATIC, T_ABSTRACT, T_CONST, T_PROPERTY, ]; if (in_array($tokens[$nextToken]['code'], $ignore, true) === true) { $phpcsFile->addError('Missing file doc comment', $stackPtr, 'Missing'); $phpcsFile->recordMetric($stackPtr, 'File has doc comment', 'no'); return ($phpcsFile->numTokens + 1); } $phpcsFile->recordMetric($stackPtr, 'File has doc comment', 'yes'); // Check the PHP Version, which should be in some text before the first tag. $found = false; for ($i = ($commentStart + 1); $i < $commentEnd; $i++) { if ($tokens[$i]['code'] === T_DOC_COMMENT_TAG) { break; } else if ($tokens[$i]['code'] === T_DOC_COMMENT_STRING && strstr(strtolower($tokens[$i]['content']), 'php version') !== false ) { $found = true; break; } } if ($found === false) { $error = 'PHP version not specified'; $phpcsFile->addWarning($error, $commentEnd, 'MissingVersion'); } // Check each tag. $this->processTags($phpcsFile, $stackPtr, $commentStart); // Ignore the rest of the file. return ($phpcsFile->numTokens + 1); }//end process() /** * Processes each required or optional tag. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param int $commentStart Position in the stack where the comment started. * * @return void */ protected function processTags($phpcsFile, $stackPtr, $commentStart) { $tokens = $phpcsFile->getTokens(); if (get_class($this) === 'PHP_CodeSniffer\Standards\PEAR\Sniffs\Commenting\FileCommentSniff') { $docBlock = 'file'; } else { $docBlock = 'class'; } $commentEnd = $tokens[$commentStart]['comment_closer']; $foundTags = []; $tagTokens = []; foreach ($tokens[$commentStart]['comment_tags'] as $tag) { $name = $tokens[$tag]['content']; if (isset($this->tags[$name]) === false) { continue; } if ($this->tags[$name]['allow_multiple'] === false && isset($tagTokens[$name]) === true) { $error = 'Only one %s tag is allowed in a %s comment'; $data = [ $name, $docBlock, ]; $phpcsFile->addError($error, $tag, 'Duplicate'.ucfirst(substr($name, 1)).'Tag', $data); } $foundTags[] = $name; $tagTokens[$name][] = $tag; $string = $phpcsFile->findNext(T_DOC_COMMENT_STRING, $tag, $commentEnd); if ($string === false || $tokens[$string]['line'] !== $tokens[$tag]['line']) { $error = 'Content missing for %s tag in %s comment'; $data = [ $name, $docBlock, ]; $phpcsFile->addError($error, $tag, 'Empty'.ucfirst(substr($name, 1)).'Tag', $data); continue; } }//end foreach // Check if the tags are in the correct position. $pos = 0; foreach ($this->tags as $tag => $tagData) { if (isset($tagTokens[$tag]) === false) { if ($tagData['required'] === true) { $error = 'Missing %s tag in %s comment'; $data = [ $tag, $docBlock, ]; $phpcsFile->addError($error, $commentEnd, 'Missing'.ucfirst(substr($tag, 1)).'Tag', $data); } continue; } else { $method = 'process'.substr($tag, 1); if (method_exists($this, $method) === true) { // Process each tag if a method is defined. call_user_func([$this, $method], $phpcsFile, $tagTokens[$tag]); } } if (isset($foundTags[$pos]) === false) { break; } if ($foundTags[$pos] !== $tag) { $error = 'The tag in position %s should be the %s tag'; $data = [ ($pos + 1), $tag, ]; $phpcsFile->addError($error, $tokens[$commentStart]['comment_tags'][$pos], ucfirst(substr($tag, 1)).'TagOrder', $data); } // Account for multiple tags. $pos++; while (isset($foundTags[$pos]) === true && $foundTags[$pos] === $tag) { $pos++; } }//end foreach }//end processTags() /** * Process the category tag. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param array $tags The tokens for these tags. * * @return void */ protected function processCategory($phpcsFile, array $tags) { $tokens = $phpcsFile->getTokens(); foreach ($tags as $tag) { if ($tokens[($tag + 2)]['code'] !== T_DOC_COMMENT_STRING) { // No content. continue; } $content = $tokens[($tag + 2)]['content']; if (Common::isUnderscoreName($content) !== true) { $newContent = str_replace(' ', '_', $content); $nameBits = explode('_', $newContent); $firstBit = array_shift($nameBits); $newName = ucfirst($firstBit).'_'; foreach ($nameBits as $bit) { if ($bit !== '') { $newName .= ucfirst($bit).'_'; } } $error = 'Category name "%s" is not valid; consider "%s" instead'; $validName = trim($newName, '_'); $data = [ $content, $validName, ]; $phpcsFile->addError($error, $tag, 'InvalidCategory', $data); } }//end foreach }//end processCategory() /** * Process the package tag. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param array $tags The tokens for these tags. * * @return void */ protected function processPackage($phpcsFile, array $tags) { $tokens = $phpcsFile->getTokens(); foreach ($tags as $tag) { if ($tokens[($tag + 2)]['code'] !== T_DOC_COMMENT_STRING) { // No content. continue; } $content = $tokens[($tag + 2)]['content']; if (Common::isUnderscoreName($content) === true) { continue; } $newContent = str_replace(' ', '_', $content); $newContent = trim($newContent, '_'); $newContent = preg_replace('/[^A-Za-z_]/', '', $newContent); if ($newContent === '') { $error = 'Package name "%s" is not valid'; $data = [$content]; $phpcsFile->addError($error, $tag, 'InvalidPackageValue', $data); } else { $nameBits = explode('_', $newContent); $firstBit = array_shift($nameBits); $newName = strtoupper($firstBit[0]).substr($firstBit, 1).'_'; foreach ($nameBits as $bit) { if ($bit !== '') { $newName .= strtoupper($bit[0]).substr($bit, 1).'_'; } } $error = 'Package name "%s" is not valid; consider "%s" instead'; $validName = trim($newName, '_'); $data = [ $content, $validName, ]; $phpcsFile->addError($error, $tag, 'InvalidPackage', $data); }//end if }//end foreach }//end processPackage() /** * Process the subpackage tag. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param array $tags The tokens for these tags. * * @return void */ protected function processSubpackage($phpcsFile, array $tags) { $tokens = $phpcsFile->getTokens(); foreach ($tags as $tag) { if ($tokens[($tag + 2)]['code'] !== T_DOC_COMMENT_STRING) { // No content. continue; } $content = $tokens[($tag + 2)]['content']; if (Common::isUnderscoreName($content) === true) { continue; } $newContent = str_replace(' ', '_', $content); $nameBits = explode('_', $newContent); $firstBit = array_shift($nameBits); $newName = strtoupper($firstBit[0]).substr($firstBit, 1).'_'; foreach ($nameBits as $bit) { if ($bit !== '') { $newName .= strtoupper($bit[0]).substr($bit, 1).'_'; } } $error = 'Subpackage name "%s" is not valid; consider "%s" instead'; $validName = trim($newName, '_'); $data = [ $content, $validName, ]; $phpcsFile->addError($error, $tag, 'InvalidSubpackage', $data); }//end foreach }//end processSubpackage() /** * Process the author tag(s) that this header comment has. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param array $tags The tokens for these tags. * * @return void */ protected function processAuthor($phpcsFile, array $tags) { $tokens = $phpcsFile->getTokens(); foreach ($tags as $tag) { if ($tokens[($tag + 2)]['code'] !== T_DOC_COMMENT_STRING) { // No content. continue; } $content = $tokens[($tag + 2)]['content']; $local = '\da-zA-Z-_+'; // Dot character cannot be the first or last character in the local-part. $localMiddle = $local.'.\w'; if (preg_match('/^([^<]*)\s+<(['.$local.'](['.$localMiddle.']*['.$local.'])*@[\da-zA-Z][-.\w]*[\da-zA-Z]\.[a-zA-Z]{2,})>$/', $content) === 0) { $error = 'Content of the @author tag must be in the form "Display Name "'; $phpcsFile->addError($error, $tag, 'InvalidAuthors'); } } }//end processAuthor() /** * Process the copyright tags. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param array $tags The tokens for these tags. * * @return void */ protected function processCopyright($phpcsFile, array $tags) { $tokens = $phpcsFile->getTokens(); foreach ($tags as $tag) { if ($tokens[($tag + 2)]['code'] !== T_DOC_COMMENT_STRING) { // No content. continue; } $content = $tokens[($tag + 2)]['content']; $matches = []; if (preg_match('/^([0-9]{4})((.{1})([0-9]{4}))? (.+)$/', $content, $matches) !== 0) { // Check earliest-latest year order. if ($matches[3] !== '' && $matches[3] !== null) { if ($matches[3] !== '-') { $error = 'A hyphen must be used between the earliest and latest year'; $phpcsFile->addError($error, $tag, 'CopyrightHyphen'); } if ($matches[4] !== '' && $matches[4] !== null && $matches[4] < $matches[1]) { $error = "Invalid year span \"$matches[1]$matches[3]$matches[4]\" found; consider \"$matches[4]-$matches[1]\" instead"; $phpcsFile->addWarning($error, $tag, 'InvalidCopyright'); } } } else { $error = '@copyright tag must contain a year and the name of the copyright holder'; $phpcsFile->addError($error, $tag, 'IncompleteCopyright'); } }//end foreach }//end processCopyright() /** * Process the license tag. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param array $tags The tokens for these tags. * * @return void */ protected function processLicense($phpcsFile, array $tags) { $tokens = $phpcsFile->getTokens(); foreach ($tags as $tag) { if ($tokens[($tag + 2)]['code'] !== T_DOC_COMMENT_STRING) { // No content. continue; } $content = $tokens[($tag + 2)]['content']; $matches = []; preg_match('/^([^\s]+)\s+(.*)/', $content, $matches); if (count($matches) !== 3) { $error = '@license tag must contain a URL and a license name'; $phpcsFile->addError($error, $tag, 'IncompleteLicense'); } } }//end processLicense() /** * Process the version tag. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param array $tags The tokens for these tags. * * @return void */ protected function processVersion($phpcsFile, array $tags) { $tokens = $phpcsFile->getTokens(); foreach ($tags as $tag) { if ($tokens[($tag + 2)]['code'] !== T_DOC_COMMENT_STRING) { // No content. continue; } $content = $tokens[($tag + 2)]['content']; if (strstr($content, 'CVS:') === false && strstr($content, 'SVN:') === false && strstr($content, 'GIT:') === false && strstr($content, 'HG:') === false ) { $error = 'Invalid version "%s" in file comment; consider "CVS: " or "SVN: " or "GIT: " or "HG: " instead'; $data = [$content]; $phpcsFile->addWarning($error, $tag, 'InvalidVersion', $data); } } }//end processVersion() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Sniffs/Commenting/FunctionCommentSniff.php0000644000076500000240000004554113614652361027725 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Sniffs\Commenting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class FunctionCommentSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_FUNCTION]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $find = Tokens::$methodPrefixes; $find[] = T_WHITESPACE; $commentEnd = $phpcsFile->findPrevious($find, ($stackPtr - 1), null, true); if ($tokens[$commentEnd]['code'] === T_COMMENT) { // Inline comments might just be closing comments for // control structures or functions instead of function comments // using the wrong comment type. If there is other code on the line, // assume they relate to that code. $prev = $phpcsFile->findPrevious($find, ($commentEnd - 1), null, true); if ($prev !== false && $tokens[$prev]['line'] === $tokens[$commentEnd]['line']) { $commentEnd = $prev; } } if ($tokens[$commentEnd]['code'] !== T_DOC_COMMENT_CLOSE_TAG && $tokens[$commentEnd]['code'] !== T_COMMENT ) { $function = $phpcsFile->getDeclarationName($stackPtr); $phpcsFile->addError( 'Missing doc comment for function %s()', $stackPtr, 'Missing', [$function] ); $phpcsFile->recordMetric($stackPtr, 'Function has doc comment', 'no'); return; } else { $phpcsFile->recordMetric($stackPtr, 'Function has doc comment', 'yes'); } if ($tokens[$commentEnd]['code'] === T_COMMENT) { $phpcsFile->addError('You must use "/**" style comments for a function comment', $stackPtr, 'WrongStyle'); return; } if ($tokens[$commentEnd]['line'] !== ($tokens[$stackPtr]['line'] - 1)) { $error = 'There must be no blank lines after the function comment'; $phpcsFile->addError($error, $commentEnd, 'SpacingAfter'); } $commentStart = $tokens[$commentEnd]['comment_opener']; foreach ($tokens[$commentStart]['comment_tags'] as $tag) { if ($tokens[$tag]['content'] === '@see') { // Make sure the tag isn't empty. $string = $phpcsFile->findNext(T_DOC_COMMENT_STRING, $tag, $commentEnd); if ($string === false || $tokens[$string]['line'] !== $tokens[$tag]['line']) { $error = 'Content missing for @see tag in function comment'; $phpcsFile->addError($error, $tag, 'EmptySees'); } } } $this->processReturn($phpcsFile, $stackPtr, $commentStart); $this->processThrows($phpcsFile, $stackPtr, $commentStart); $this->processParams($phpcsFile, $stackPtr, $commentStart); }//end process() /** * Process the return comment of this function comment. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param int $commentStart The position in the stack where the comment started. * * @return void */ protected function processReturn(File $phpcsFile, $stackPtr, $commentStart) { $tokens = $phpcsFile->getTokens(); // Skip constructor and destructor. $methodName = $phpcsFile->getDeclarationName($stackPtr); $isSpecialMethod = ($methodName === '__construct' || $methodName === '__destruct'); $return = null; foreach ($tokens[$commentStart]['comment_tags'] as $tag) { if ($tokens[$tag]['content'] === '@return') { if ($return !== null) { $error = 'Only 1 @return tag is allowed in a function comment'; $phpcsFile->addError($error, $tag, 'DuplicateReturn'); return; } $return = $tag; } } if ($isSpecialMethod === true) { return; } if ($return !== null) { $content = $tokens[($return + 2)]['content']; if (empty($content) === true || $tokens[($return + 2)]['code'] !== T_DOC_COMMENT_STRING) { $error = 'Return type missing for @return tag in function comment'; $phpcsFile->addError($error, $return, 'MissingReturnType'); } } else { $error = 'Missing @return tag in function comment'; $phpcsFile->addError($error, $tokens[$commentStart]['comment_closer'], 'MissingReturn'); }//end if }//end processReturn() /** * Process any throw tags that this function comment has. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param int $commentStart The position in the stack where the comment started. * * @return void */ protected function processThrows(File $phpcsFile, $stackPtr, $commentStart) { $tokens = $phpcsFile->getTokens(); foreach ($tokens[$commentStart]['comment_tags'] as $tag) { if ($tokens[$tag]['content'] !== '@throws') { continue; } $exception = null; if ($tokens[($tag + 2)]['code'] === T_DOC_COMMENT_STRING) { $matches = []; preg_match('/([^\s]+)(?:\s+(.*))?/', $tokens[($tag + 2)]['content'], $matches); $exception = $matches[1]; } if ($exception === null) { $error = 'Exception type missing for @throws tag in function comment'; $phpcsFile->addError($error, $tag, 'InvalidThrows'); } }//end foreach }//end processThrows() /** * Process the function parameter comments. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param int $commentStart The position in the stack where the comment started. * * @return void */ protected function processParams(File $phpcsFile, $stackPtr, $commentStart) { $tokens = $phpcsFile->getTokens(); $params = []; $maxType = 0; $maxVar = 0; foreach ($tokens[$commentStart]['comment_tags'] as $pos => $tag) { if ($tokens[$tag]['content'] !== '@param') { continue; } $type = ''; $typeSpace = 0; $var = ''; $varSpace = 0; $comment = ''; $commentEnd = 0; $commentTokens = []; if ($tokens[($tag + 2)]['code'] === T_DOC_COMMENT_STRING) { $matches = []; preg_match('/((?:(?![$.]|&(?=\$)).)*)(?:((?:\.\.\.)?(?:\$|&)[^\s]+)(?:(\s+)(.*))?)?/', $tokens[($tag + 2)]['content'], $matches); if (empty($matches) === false) { $typeLen = strlen($matches[1]); $type = trim($matches[1]); $typeSpace = ($typeLen - strlen($type)); $typeLen = strlen($type); if ($typeLen > $maxType) { $maxType = $typeLen; } } if (isset($matches[2]) === true) { $var = $matches[2]; $varLen = strlen($var); if ($varLen > $maxVar) { $maxVar = $varLen; } if (isset($matches[4]) === true) { $varSpace = strlen($matches[3]); $comment = $matches[4]; // Any strings until the next tag belong to this comment. if (isset($tokens[$commentStart]['comment_tags'][($pos + 1)]) === true) { $end = $tokens[$commentStart]['comment_tags'][($pos + 1)]; } else { $end = $tokens[$commentStart]['comment_closer']; } for ($i = ($tag + 3); $i < $end; $i++) { if ($tokens[$i]['code'] === T_DOC_COMMENT_STRING) { $comment .= ' '.$tokens[$i]['content']; $commentEnd = $i; $commentTokens[] = $i; } } } else { $error = 'Missing parameter comment'; $phpcsFile->addError($error, $tag, 'MissingParamComment'); }//end if } else { $error = 'Missing parameter name'; $phpcsFile->addError($error, $tag, 'MissingParamName'); }//end if } else { $error = 'Missing parameter type'; $phpcsFile->addError($error, $tag, 'MissingParamType'); }//end if $params[] = [ 'tag' => $tag, 'type' => $type, 'var' => $var, 'comment' => $comment, 'comment_end' => $commentEnd, 'comment_tokens' => $commentTokens, 'type_space' => $typeSpace, 'var_space' => $varSpace, ]; }//end foreach $realParams = $phpcsFile->getMethodParameters($stackPtr); $foundParams = []; // We want to use ... for all variable length arguments, so add // this prefix to the variable name so comparisons are easier. foreach ($realParams as $pos => $param) { if ($param['variable_length'] === true) { $realParams[$pos]['name'] = '...'.$realParams[$pos]['name']; } } foreach ($params as $pos => $param) { if ($param['var'] === '') { continue; } $foundParams[] = $param['var']; if (trim($param['type']) !== '') { // Check number of spaces after the type. $spaces = ($maxType - strlen($param['type']) + 1); if ($param['type_space'] !== $spaces) { $error = 'Expected %s spaces after parameter type; %s found'; $data = [ $spaces, $param['type_space'], ]; $fix = $phpcsFile->addFixableError($error, $param['tag'], 'SpacingAfterParamType', $data); if ($fix === true) { $commentToken = ($param['tag'] + 2); $content = $param['type']; $content .= str_repeat(' ', $spaces); $content .= $param['var']; $content .= str_repeat(' ', $param['var_space']); $wrapLength = ($tokens[$commentToken]['length'] - $param['type_space'] - $param['var_space'] - strlen($param['type']) - strlen($param['var'])); $star = $phpcsFile->findPrevious(T_DOC_COMMENT_STAR, $param['tag']); $spaceLength = (strlen($content) + $tokens[($commentToken - 1)]['length'] + $tokens[($commentToken - 2)]['length']); $padding = str_repeat(' ', ($tokens[$star]['column'] - 1)); $padding .= '* '; $padding .= str_repeat(' ', $spaceLength); $content .= wordwrap( $param['comment'], $wrapLength, $phpcsFile->eolChar.$padding ); $phpcsFile->fixer->replaceToken($commentToken, $content); for ($i = ($commentToken + 1); $i <= $param['comment_end']; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } }//end if }//end if }//end if // Make sure the param name is correct. if (isset($realParams[$pos]) === true) { $realName = $realParams[$pos]['name']; if ($realName !== $param['var']) { $code = 'ParamNameNoMatch'; $data = [ $param['var'], $realName, ]; $error = 'Doc comment for parameter %s does not match '; if (strtolower($param['var']) === strtolower($realName)) { $error .= 'case of '; $code = 'ParamNameNoCaseMatch'; } $error .= 'actual variable name %s'; $phpcsFile->addError($error, $param['tag'], $code, $data); } } else if (substr($param['var'], -4) !== ',...') { // We must have an extra parameter comment. $error = 'Superfluous parameter comment'; $phpcsFile->addError($error, $param['tag'], 'ExtraParamComment'); }//end if if ($param['comment'] === '') { continue; } // Check number of spaces after the param name. $spaces = ($maxVar - strlen($param['var']) + 1); if ($param['var_space'] !== $spaces) { $error = 'Expected %s spaces after parameter name; %s found'; $data = [ $spaces, $param['var_space'], ]; $fix = $phpcsFile->addFixableError($error, $param['tag'], 'SpacingAfterParamName', $data); if ($fix === true) { $commentToken = ($param['tag'] + 2); $content = $param['type']; $content .= str_repeat(' ', $param['type_space']); $content .= $param['var']; $content .= str_repeat(' ', $spaces); $wrapLength = ($tokens[$commentToken]['length'] - $param['type_space'] - $param['var_space'] - strlen($param['type']) - strlen($param['var'])); $star = $phpcsFile->findPrevious(T_DOC_COMMENT_STAR, $param['tag']); $spaceLength = (strlen($content) + $tokens[($commentToken - 1)]['length'] + $tokens[($commentToken - 2)]['length']); $padding = str_repeat(' ', ($tokens[$star]['column'] - 1)); $padding .= '* '; $padding .= str_repeat(' ', $spaceLength); $content .= wordwrap( $param['comment'], $wrapLength, $phpcsFile->eolChar.$padding ); $phpcsFile->fixer->replaceToken($commentToken, $content); for ($i = ($commentToken + 1); $i <= $param['comment_end']; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } }//end if }//end if // Check the alignment of multi-line param comments. if ($param['tag'] !== $param['comment_end']) { $wrapLength = ($tokens[($param['tag'] + 2)]['length'] - $param['type_space'] - $param['var_space'] - strlen($param['type']) - strlen($param['var'])); $startColumn = ($tokens[($param['tag'] + 2)]['column'] + $tokens[($param['tag'] + 2)]['length'] - $wrapLength); $star = $phpcsFile->findPrevious(T_DOC_COMMENT_STAR, $param['tag']); $expected = ($startColumn - $tokens[$star]['column'] - 1); foreach ($param['comment_tokens'] as $commentToken) { if ($tokens[$commentToken]['column'] === $startColumn) { continue; } $found = 0; if ($tokens[($commentToken - 1)]['code'] === T_DOC_COMMENT_WHITESPACE) { $found = $tokens[($commentToken - 1)]['length']; } $error = 'Parameter comment not aligned correctly; expected %s spaces but found %s'; $data = [ $expected, $found, ]; if ($found < $expected) { $code = 'ParamCommentAlignment'; } else { $code = 'ParamCommentAlignmentExceeded'; } $fix = $phpcsFile->addFixableError($error, $commentToken, $code, $data); if ($fix === true) { $padding = str_repeat(' ', $expected); if ($tokens[($commentToken - 1)]['code'] === T_DOC_COMMENT_WHITESPACE) { $phpcsFile->fixer->replaceToken(($commentToken - 1), $padding); } else { $phpcsFile->fixer->addContentBefore($commentToken, $padding); } } }//end foreach }//end if }//end foreach $realNames = []; foreach ($realParams as $realParam) { $realNames[] = $realParam['name']; } // Report missing comments. $diff = array_diff($realNames, $foundParams); foreach ($diff as $neededParam) { $error = 'Doc comment for parameter "%s" missing'; $data = [$neededParam]; $phpcsFile->addError($error, $commentStart, 'MissingParamTag', $data); } }//end processParams() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Sniffs/Commenting/InlineCommentSniff.php0000644000076500000240000000421313614652361027345 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Sniffs\Commenting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class InlineCommentSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_COMMENT]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if ($tokens[$stackPtr]['content'][0] === '#') { $phpcsFile->recordMetric($stackPtr, 'Inline comment style', '# ...'); $error = 'Perl-style comments are not allowed. Use "// Comment."'; $error .= ' or "/* comment */" instead.'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'WrongStyle'); if ($fix === true) { $newComment = ltrim($tokens[$stackPtr]['content'], '# '); $newComment = '// '.$newComment; $phpcsFile->fixer->replaceToken($stackPtr, $newComment); } } else if ($tokens[$stackPtr]['content'][0] === '/' && $tokens[$stackPtr]['content'][1] === '/' ) { $phpcsFile->recordMetric($stackPtr, 'Inline comment style', '// ...'); } else if ($tokens[$stackPtr]['content'][0] === '/' && $tokens[$stackPtr]['content'][1] === '*' ) { $phpcsFile->recordMetric($stackPtr, 'Inline comment style', '/* ... */'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Sniffs/ControlStructures/ControlSignatureSniff.php0000644000076500000240000000215413614652361031534 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Sniffs\ControlStructures; use PHP_CodeSniffer\Sniffs\AbstractPatternSniff; class ControlSignatureSniff extends AbstractPatternSniff { /** * If true, comments will be ignored if they are found in the code. * * @var boolean */ public $ignoreComments = true; /** * Returns the patterns that this test wishes to verify. * * @return string[] */ protected function getPatterns() { return [ 'do {EOL...} while (...);EOL', 'while (...) {EOL', 'for (...) {EOL', 'if (...) {EOL', 'foreach (...) {EOL', '} else if (...) {EOL', '} elseif (...) {EOL', '} else {EOL', 'do {EOL', ]; }//end getPatterns() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Sniffs/ControlStructures/MultiLineConditionSniff.php0000644000076500000240000002657013614652361032013 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Sniffs\ControlStructures; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class MultiLineConditionSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * The number of spaces code should be indented. * * @var integer */ public $indent = 4; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_IF, T_ELSEIF, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['parenthesis_opener']) === false) { return; } $openBracket = $tokens[$stackPtr]['parenthesis_opener']; $closeBracket = $tokens[$stackPtr]['parenthesis_closer']; $spaceAfterOpen = 0; if ($tokens[($openBracket + 1)]['code'] === T_WHITESPACE) { if (strpos($tokens[($openBracket + 1)]['content'], $phpcsFile->eolChar) !== false) { $spaceAfterOpen = 'newline'; } else { $spaceAfterOpen = $tokens[($openBracket + 1)]['length']; } } if ($spaceAfterOpen !== 0) { $error = 'First condition of a multi-line IF statement must directly follow the opening parenthesis'; $fix = $phpcsFile->addFixableError($error, ($openBracket + 1), 'SpacingAfterOpenBrace'); if ($fix === true) { if ($spaceAfterOpen === 'newline') { $phpcsFile->fixer->replaceToken(($openBracket + 1), ''); } else { $phpcsFile->fixer->replaceToken(($openBracket + 1), ''); } } } // We need to work out how far indented the if statement // itself is, so we can work out how far to indent conditions. $statementIndent = 0; for ($i = ($stackPtr - 1); $i >= 0; $i--) { if ($tokens[$i]['line'] !== $tokens[$stackPtr]['line']) { $i++; break; } } if ($i >= 0 && $tokens[$i]['code'] === T_WHITESPACE) { $statementIndent = $tokens[$i]['length']; } // Each line between the parenthesis should be indented 4 spaces // and start with an operator, unless the line is inside a // function call, in which case it is ignored. $prevLine = $tokens[$openBracket]['line']; for ($i = ($openBracket + 1); $i <= $closeBracket; $i++) { if ($i === $closeBracket && $tokens[$openBracket]['line'] !== $tokens[$i]['line']) { $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($i - 1), null, true); if ($tokens[$prev]['line'] === $tokens[$i]['line']) { // Closing bracket is on the same line as a condition. $error = 'Closing parenthesis of a multi-line IF statement must be on a new line'; $fix = $phpcsFile->addFixableError($error, $closeBracket, 'CloseBracketNewLine'); if ($fix === true) { // Account for a comment at the end of the line. $next = $phpcsFile->findNext(T_WHITESPACE, ($closeBracket + 1), null, true); if ($tokens[$next]['code'] !== T_COMMENT && isset(Tokens::$phpcsCommentTokens[$tokens[$next]['code']]) === false ) { $phpcsFile->fixer->addNewlineBefore($closeBracket); } else { $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($next + 1), null, true); $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->replaceToken($closeBracket, ''); $phpcsFile->fixer->addContentBefore($next, ')'); $phpcsFile->fixer->endChangeset(); } } } }//end if if ($tokens[$i]['line'] !== $prevLine) { if ($tokens[$i]['line'] === $tokens[$closeBracket]['line']) { $next = $phpcsFile->findNext(T_WHITESPACE, $i, null, true); if ($next !== $closeBracket) { $expectedIndent = ($statementIndent + $this->indent); } else { // Closing brace needs to be indented to the same level // as the statement. $expectedIndent = $statementIndent; }//end if } else { $expectedIndent = ($statementIndent + $this->indent); }//end if if ($tokens[$i]['code'] === T_COMMENT || isset(Tokens::$phpcsCommentTokens[$tokens[$i]['code']]) === true ) { $prevLine = $tokens[$i]['line']; continue; } // We changed lines, so this should be a whitespace indent token. if ($tokens[$i]['code'] !== T_WHITESPACE) { $foundIndent = 0; } else { $foundIndent = $tokens[$i]['length']; } if ($expectedIndent !== $foundIndent) { $error = 'Multi-line IF statement not indented correctly; expected %s spaces but found %s'; $data = [ $expectedIndent, $foundIndent, ]; $fix = $phpcsFile->addFixableError($error, $i, 'Alignment', $data); if ($fix === true) { $spaces = str_repeat(' ', $expectedIndent); if ($foundIndent === 0) { $phpcsFile->fixer->addContentBefore($i, $spaces); } else { $phpcsFile->fixer->replaceToken($i, $spaces); } } } $next = $phpcsFile->findNext(Tokens::$emptyTokens, $i, null, true); if ($next !== $closeBracket && $tokens[$next]['line'] === $tokens[$i]['line']) { if (isset(Tokens::$booleanOperators[$tokens[$next]['code']]) === false) { $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($i - 1), $openBracket, true); $fixable = true; if (isset(Tokens::$booleanOperators[$tokens[$prev]['code']]) === false && $phpcsFile->findNext(T_WHITESPACE, ($prev + 1), $next, true) !== false ) { // Condition spread over multi-lines interspersed with comments. $fixable = false; } $error = 'Each line in a multi-line IF statement must begin with a boolean operator'; if ($fixable === false) { $phpcsFile->addError($error, $next, 'StartWithBoolean'); } else { $fix = $phpcsFile->addFixableError($error, $next, 'StartWithBoolean'); if ($fix === true) { if (isset(Tokens::$booleanOperators[$tokens[$prev]['code']]) === true) { $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->replaceToken($prev, ''); $phpcsFile->fixer->addContentBefore($next, $tokens[$prev]['content'].' '); $phpcsFile->fixer->endChangeset(); } else { for ($x = ($prev + 1); $x < $next; $x++) { $phpcsFile->fixer->replaceToken($x, ''); } } } } }//end if }//end if $prevLine = $tokens[$i]['line']; }//end if if ($tokens[$i]['code'] === T_STRING) { $next = $phpcsFile->findNext(T_WHITESPACE, ($i + 1), null, true); if ($tokens[$next]['code'] === T_OPEN_PARENTHESIS) { // This is a function call, so skip to the end as they // have their own indentation rules. $i = $tokens[$next]['parenthesis_closer']; $prevLine = $tokens[$i]['line']; continue; } } }//end for // From here on, we are checking the spacing of the opening and closing // braces. If this IF statement does not use braces, we end here. if (isset($tokens[$stackPtr]['scope_opener']) === false) { return; } // The opening brace needs to be one space away from the closing parenthesis. $openBrace = $tokens[$stackPtr]['scope_opener']; $next = $phpcsFile->findNext(T_WHITESPACE, ($closeBracket + 1), $openBrace, true); if ($next !== false) { // Probably comments in between tokens, so don't check. return; } if ($tokens[$openBrace]['line'] > $tokens[$closeBracket]['line']) { $length = -1; } else if ($openBrace === ($closeBracket + 1)) { $length = 0; } else if ($openBrace === ($closeBracket + 2) && $tokens[($closeBracket + 1)]['code'] === T_WHITESPACE ) { $length = $tokens[($closeBracket + 1)]['length']; } else { // Confused, so don't check. $length = 1; } if ($length === 1) { return; } $data = [$length]; $code = 'SpaceBeforeOpenBrace'; $error = 'There must be a single space between the closing parenthesis and the opening brace of a multi-line IF statement; found '; if ($length === -1) { $error .= 'newline'; $code = 'NewlineBeforeOpenBrace'; } else { $error .= '%s spaces'; } $fix = $phpcsFile->addFixableError($error, ($closeBracket + 1), $code, $data); if ($fix === true) { if ($length === 0) { $phpcsFile->fixer->addContent($closeBracket, ' '); } else { $phpcsFile->fixer->replaceToken(($closeBracket + 1), ' '); } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Sniffs/Files/IncludingFileSniff.php0000644000076500000240000001240313614652361026262 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Sniffs\Files; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class IncludingFileSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_INCLUDE_ONCE, T_REQUIRE_ONCE, T_REQUIRE, T_INCLUDE, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $nextToken = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true); if ($tokens[$nextToken]['code'] === T_OPEN_PARENTHESIS) { $error = '"%s" is a statement not a function; no parentheses are required'; $data = [$tokens[$stackPtr]['content']]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'BracketsNotRequired', $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->replaceToken($tokens[$nextToken]['parenthesis_closer'], ''); if ($tokens[($nextToken - 1)]['code'] !== T_WHITESPACE) { $phpcsFile->fixer->replaceToken($nextToken, ' '); } else { $phpcsFile->fixer->replaceToken($nextToken, ''); } $phpcsFile->fixer->endChangeset(); } } if (count($tokens[$stackPtr]['conditions']) !== 0) { $inCondition = true; } else { $inCondition = false; } // Check to see if this including statement is within the parenthesis // of a condition. If that's the case then we need to process it as being // within a condition, as they are checking the return value. if (isset($tokens[$stackPtr]['nested_parenthesis']) === true) { foreach ($tokens[$stackPtr]['nested_parenthesis'] as $left => $right) { if (isset($tokens[$left]['parenthesis_owner']) === true) { $inCondition = true; } } } // Check to see if they are assigning the return value of this // including call. If they are then they are probably checking it, so // it's conditional. $previous = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); if (isset(Tokens::$assignmentTokens[$tokens[$previous]['code']]) === true) { // The have assigned the return value to it, so its conditional. $inCondition = true; } $tokenCode = $tokens[$stackPtr]['code']; if ($inCondition === true) { // We are inside a conditional statement. We need an include_once. if ($tokenCode === T_REQUIRE_ONCE) { $error = 'File is being conditionally included; '; $error .= 'use "include_once" instead'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'UseIncludeOnce'); if ($fix === true) { $phpcsFile->fixer->replaceToken($stackPtr, 'include_once'); } } else if ($tokenCode === T_REQUIRE) { $error = 'File is being conditionally included; '; $error .= 'use "include" instead'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'UseInclude'); if ($fix === true) { $phpcsFile->fixer->replaceToken($stackPtr, 'include'); } } } else { // We are unconditionally including, we need a require_once. if ($tokenCode === T_INCLUDE_ONCE) { $error = 'File is being unconditionally included; '; $error .= 'use "require_once" instead'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'UseRequireOnce'); if ($fix === true) { $phpcsFile->fixer->replaceToken($stackPtr, 'require_once'); } } else if ($tokenCode === T_INCLUDE) { $error = 'File is being unconditionally included; '; $error .= 'use "require" instead'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'UseRequire'); if ($fix === true) { $phpcsFile->fixer->replaceToken($stackPtr, 'require'); } } }//end if }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Sniffs/Formatting/MultiLineAssignmentSniff.php0000644000076500000240000000613213614652361030553 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Sniffs\Formatting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class MultiLineAssignmentSniff implements Sniff { /** * The number of spaces code should be indented. * * @var integer */ public $indent = 4; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_EQUAL]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Equal sign can't be the last thing on the line. $next = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($next === false) { // Bad assignment. return; } if ($tokens[$next]['line'] !== $tokens[$stackPtr]['line']) { $error = 'Multi-line assignments must have the equal sign on the second line'; $phpcsFile->addError($error, $stackPtr, 'EqualSignLine'); return; } // Make sure it is the first thing on the line, otherwise we ignore it. $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), false, true); if ($prev === false) { // Bad assignment. return; } if ($tokens[$prev]['line'] === $tokens[$stackPtr]['line']) { return; } // Find the required indent based on the ident of the previous line. $assignmentIndent = 0; $prevLine = $tokens[$prev]['line']; for ($i = ($prev - 1); $i >= 0; $i--) { if ($tokens[$i]['line'] !== $prevLine) { $i++; break; } } if ($tokens[$i]['code'] === T_WHITESPACE) { $assignmentIndent = $tokens[$i]['length']; } // Find the actual indent. $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1)); $expectedIndent = ($assignmentIndent + $this->indent); $foundIndent = $tokens[$prev]['length']; if ($foundIndent !== $expectedIndent) { $error = 'Multi-line assignment not indented correctly; expected %s spaces but found %s'; $data = [ $expectedIndent, $foundIndent, ]; $phpcsFile->addError($error, $stackPtr, 'Indent', $data); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Sniffs/Functions/FunctionCallSignatureSniff.php0000644000076500000240000006371313614652361030731 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Sniffs\Functions; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class FunctionCallSignatureSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * The number of spaces code should be indented. * * @var integer */ public $indent = 4; /** * If TRUE, multiple arguments can be defined per line in a multi-line call. * * @var boolean */ public $allowMultipleArguments = true; /** * How many spaces should follow the opening bracket. * * @var integer */ public $requiredSpacesAfterOpen = 0; /** * How many spaces should precede the closing bracket. * * @var integer */ public $requiredSpacesBeforeClose = 0; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { $tokens = Tokens::$functionNameTokens; $tokens[] = T_VARIABLE; $tokens[] = T_CLOSE_CURLY_BRACKET; $tokens[] = T_CLOSE_PARENTHESIS; return $tokens; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $this->requiredSpacesAfterOpen = (int) $this->requiredSpacesAfterOpen; $this->requiredSpacesBeforeClose = (int) $this->requiredSpacesBeforeClose; $tokens = $phpcsFile->getTokens(); if ($tokens[$stackPtr]['code'] === T_CLOSE_CURLY_BRACKET && isset($tokens[$stackPtr]['scope_condition']) === true ) { // Not a function call. return; } // Find the next non-empty token. $openBracket = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true); if ($tokens[$openBracket]['code'] !== T_OPEN_PARENTHESIS) { // Not a function call. return; } if (isset($tokens[$openBracket]['parenthesis_closer']) === false) { // Not a function call. return; } // Find the previous non-empty token. $search = Tokens::$emptyTokens; $search[] = T_BITWISE_AND; $previous = $phpcsFile->findPrevious($search, ($stackPtr - 1), null, true); if ($tokens[$previous]['code'] === T_FUNCTION) { // It's a function definition, not a function call. return; } $closeBracket = $tokens[$openBracket]['parenthesis_closer']; if (($stackPtr + 1) !== $openBracket) { // Checking this: $value = my_function[*](...). $error = 'Space before opening parenthesis of function call prohibited'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceBeforeOpenBracket'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($stackPtr + 1); $i < $openBracket; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } // Modify the bracket as well to ensure a conflict if the bracket // has been changed in some way by another sniff. $phpcsFile->fixer->replaceToken($openBracket, '('); $phpcsFile->fixer->endChangeset(); } } $next = $phpcsFile->findNext(T_WHITESPACE, ($closeBracket + 1), null, true); if ($tokens[$next]['code'] === T_SEMICOLON) { if (isset(Tokens::$emptyTokens[$tokens[($closeBracket + 1)]['code']]) === true) { $error = 'Space after closing parenthesis of function call prohibited'; $fix = $phpcsFile->addFixableError($error, $closeBracket, 'SpaceAfterCloseBracket'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($closeBracket + 1); $i < $next; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } // Modify the bracket as well to ensure a conflict if the bracket // has been changed in some way by another sniff. $phpcsFile->fixer->replaceToken($closeBracket, ')'); $phpcsFile->fixer->endChangeset(); } } } // Check if this is a single line or multi-line function call. if ($this->isMultiLineCall($phpcsFile, $stackPtr, $openBracket, $tokens) === true) { $this->processMultiLineCall($phpcsFile, $stackPtr, $openBracket, $tokens); } else { $this->processSingleLineCall($phpcsFile, $stackPtr, $openBracket, $tokens); } }//end process() /** * Determine if this is a multi-line function call. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param int $openBracket The position of the opening bracket * in the stack passed in $tokens. * @param array $tokens The stack of tokens that make up * the file. * * @return bool */ public function isMultiLineCall(File $phpcsFile, $stackPtr, $openBracket, $tokens) { $closeBracket = $tokens[$openBracket]['parenthesis_closer']; if ($tokens[$openBracket]['line'] !== $tokens[$closeBracket]['line']) { return true; } return false; }//end isMultiLineCall() /** * Processes single-line calls. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param int $openBracket The position of the opening bracket * in the stack passed in $tokens. * @param array $tokens The stack of tokens that make up * the file. * * @return void */ public function processSingleLineCall(File $phpcsFile, $stackPtr, $openBracket, $tokens) { $closer = $tokens[$openBracket]['parenthesis_closer']; if ($openBracket === ($closer - 1)) { return; } // If the function call has no arguments or comments, enforce 0 spaces. $next = $phpcsFile->findNext(T_WHITESPACE, ($openBracket + 1), $closer, true); if ($next === false) { $requiredSpacesAfterOpen = 0; $requiredSpacesBeforeClose = 0; } else { $requiredSpacesAfterOpen = $this->requiredSpacesAfterOpen; $requiredSpacesBeforeClose = $this->requiredSpacesBeforeClose; } if ($requiredSpacesAfterOpen === 0 && $tokens[($openBracket + 1)]['code'] === T_WHITESPACE) { // Checking this: $value = my_function([*]...). $error = 'Space after opening parenthesis of function call prohibited'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceAfterOpenBracket'); if ($fix === true) { $phpcsFile->fixer->replaceToken(($openBracket + 1), ''); } } else if ($requiredSpacesAfterOpen > 0) { $spaceAfterOpen = 0; if ($tokens[($openBracket + 1)]['code'] === T_WHITESPACE) { $spaceAfterOpen = $tokens[($openBracket + 1)]['length']; } if ($spaceAfterOpen !== $requiredSpacesAfterOpen) { $error = 'Expected %s spaces after opening bracket; %s found'; $data = [ $requiredSpacesAfterOpen, $spaceAfterOpen, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceAfterOpenBracket', $data); if ($fix === true) { $padding = str_repeat(' ', $requiredSpacesAfterOpen); if ($spaceAfterOpen === 0) { $phpcsFile->fixer->addContent($openBracket, $padding); } else { $phpcsFile->fixer->replaceToken(($openBracket + 1), $padding); } } } }//end if // Checking this: $value = my_function(...[*]). $spaceBeforeClose = 0; $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($closer - 1), $openBracket, true); if ($tokens[$prev]['code'] === T_END_HEREDOC || $tokens[$prev]['code'] === T_END_NOWDOC) { // Need a newline after these tokens, so ignore this rule. return; } if ($tokens[$prev]['line'] !== $tokens[$closer]['line']) { $spaceBeforeClose = 'newline'; } else if ($tokens[($closer - 1)]['code'] === T_WHITESPACE) { $spaceBeforeClose = $tokens[($closer - 1)]['length']; } if ($spaceBeforeClose !== $requiredSpacesBeforeClose) { $error = 'Expected %s spaces before closing bracket; %s found'; $data = [ $requiredSpacesBeforeClose, $spaceBeforeClose, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceBeforeCloseBracket', $data); if ($fix === true) { $padding = str_repeat(' ', $requiredSpacesBeforeClose); if ($spaceBeforeClose === 0) { $phpcsFile->fixer->addContentBefore($closer, $padding); } else if ($spaceBeforeClose === 'newline') { $phpcsFile->fixer->beginChangeset(); $closingContent = ')'; $next = $phpcsFile->findNext(T_WHITESPACE, ($closer + 1), null, true); if ($tokens[$next]['code'] === T_SEMICOLON) { $closingContent .= ';'; for ($i = ($closer + 1); $i <= $next; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } } // We want to jump over any whitespace or inline comment and // move the closing parenthesis after any other token. $prev = ($closer - 1); while (isset(Tokens::$emptyTokens[$tokens[$prev]['code']]) === true) { if (($tokens[$prev]['code'] === T_COMMENT) && (strpos($tokens[$prev]['content'], '*/') !== false) ) { break; } $prev--; } $phpcsFile->fixer->addContent($prev, $padding.$closingContent); $prevNonWhitespace = $phpcsFile->findPrevious(T_WHITESPACE, ($closer - 1), null, true); for ($i = ($prevNonWhitespace + 1); $i <= $closer; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } else { $phpcsFile->fixer->replaceToken(($closer - 1), $padding); }//end if }//end if }//end if }//end processSingleLineCall() /** * Processes multi-line calls. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param int $openBracket The position of the opening bracket * in the stack passed in $tokens. * @param array $tokens The stack of tokens that make up * the file. * * @return void */ public function processMultiLineCall(File $phpcsFile, $stackPtr, $openBracket, $tokens) { // We need to work out how far indented the function // call itself is, so we can work out how far to // indent the arguments. $first = $phpcsFile->findFirstOnLine(T_WHITESPACE, $stackPtr, true); if ($tokens[$first]['code'] === T_CONSTANT_ENCAPSED_STRING && $tokens[($first - 1)]['code'] === T_CONSTANT_ENCAPSED_STRING ) { // We are in a multi-line string, so find the start and use // the indent from there. $prev = $phpcsFile->findPrevious(T_CONSTANT_ENCAPSED_STRING, ($first - 2), null, true); $first = $phpcsFile->findFirstOnLine(Tokens::$emptyTokens, $prev, true); if ($first === false) { $first = ($prev + 1); } } $foundFunctionIndent = 0; if ($first !== false) { if ($tokens[$first]['code'] === T_INLINE_HTML || ($tokens[$first]['code'] === T_CONSTANT_ENCAPSED_STRING && $tokens[($first - 1)]['code'] === T_CONSTANT_ENCAPSED_STRING) ) { $trimmed = ltrim($tokens[$first]['content']); if ($trimmed === '') { $foundFunctionIndent = strlen($tokens[$first]['content']); } else { $foundFunctionIndent = (strlen($tokens[$first]['content']) - strlen($trimmed)); } } else { $foundFunctionIndent = ($tokens[$first]['column'] - 1); } } // Make sure the function indent is divisible by the indent size. // We round down here because this accounts for times when the // surrounding code is indented a little too far in, and not correctly // at a tab stop. Without this, the function will be indented a further // $indent spaces to the right. $functionIndent = (int) (floor($foundFunctionIndent / $this->indent) * $this->indent); $adjustment = 0; if ($foundFunctionIndent !== $functionIndent) { $error = 'Opening statement of multi-line function call not indented correctly; expected %s spaces but found %s'; $data = [ $functionIndent, $foundFunctionIndent, ]; $fix = $phpcsFile->addFixableError($error, $first, 'OpeningIndent', $data); if ($fix === true) { $adjustment = ($functionIndent - $foundFunctionIndent); $padding = str_repeat(' ', $functionIndent); if ($foundFunctionIndent === 0) { $phpcsFile->fixer->addContentBefore($first, $padding); } else { $phpcsFile->fixer->replaceToken(($first - 1), $padding); } } } $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($openBracket + 1), null, true); if ($tokens[$next]['line'] === $tokens[$openBracket]['line']) { $error = 'Opening parenthesis of a multi-line function call must be the last content on the line'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'ContentAfterOpenBracket'); if ($fix === true) { $phpcsFile->fixer->addContent( $openBracket, $phpcsFile->eolChar.str_repeat(' ', ($foundFunctionIndent + $this->indent)) ); } } $closeBracket = $tokens[$openBracket]['parenthesis_closer']; $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($closeBracket - 1), null, true); if ($tokens[$prev]['line'] === $tokens[$closeBracket]['line']) { $error = 'Closing parenthesis of a multi-line function call must be on a line by itself'; $fix = $phpcsFile->addFixableError($error, $closeBracket, 'CloseBracketLine'); if ($fix === true) { $phpcsFile->fixer->addContentBefore( $closeBracket, $phpcsFile->eolChar.str_repeat(' ', ($foundFunctionIndent + $this->indent)) ); } } // Each line between the parenthesis should be indented n spaces. $lastLine = ($tokens[$openBracket]['line'] - 1); $argStart = null; $argEnd = null; // Start processing at the first argument. $i = $phpcsFile->findNext(T_WHITESPACE, ($openBracket + 1), null, true); if ($tokens[$i]['line'] > ($tokens[$openBracket]['line'] + 1)) { $error = 'The first argument in a multi-line function call must be on the line after the opening parenthesis'; $fix = $phpcsFile->addFixableError($error, $i, 'FirstArgumentPosition'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($x = ($openBracket + 1); $x < $i; $x++) { if ($tokens[$x]['line'] === $tokens[$openBracket]['line']) { continue; } if ($tokens[$x]['line'] === $tokens[$i]['line']) { break; } $phpcsFile->fixer->replaceToken($x, ''); } $phpcsFile->fixer->endChangeset(); } }//end if $i = $phpcsFile->findNext(Tokens::$emptyTokens, ($openBracket + 1), null, true); if ($tokens[($i - 1)]['code'] === T_WHITESPACE && $tokens[($i - 1)]['line'] === $tokens[$i]['line'] ) { // Make sure we check the indent. $i--; } for ($i; $i < $closeBracket; $i++) { if ($i > $argStart && $i < $argEnd) { $inArg = true; } else { $inArg = false; } if ($tokens[$i]['line'] !== $lastLine) { $lastLine = $tokens[$i]['line']; // Ignore heredoc indentation. if (isset(Tokens::$heredocTokens[$tokens[$i]['code']]) === true) { continue; } // Ignore multi-line string indentation. if (isset(Tokens::$stringTokens[$tokens[$i]['code']]) === true && $tokens[$i]['code'] === $tokens[($i - 1)]['code'] ) { continue; } // Ignore inline HTML. if ($tokens[$i]['code'] === T_INLINE_HTML) { continue; } if ($tokens[$i]['line'] !== $tokens[$openBracket]['line']) { // We changed lines, so this should be a whitespace indent token, but first make // sure it isn't a blank line because we don't need to check indent unless there // is actually some code to indent. if ($tokens[$i]['code'] === T_WHITESPACE) { $nextCode = $phpcsFile->findNext(T_WHITESPACE, ($i + 1), ($closeBracket + 1), true); if ($tokens[$nextCode]['line'] !== $lastLine) { if ($inArg === false) { $error = 'Empty lines are not allowed in multi-line function calls'; $fix = $phpcsFile->addFixableError($error, $i, 'EmptyLine'); if ($fix === true) { $phpcsFile->fixer->replaceToken($i, ''); } } continue; } } else { $nextCode = $i; } if ($tokens[$nextCode]['line'] === $tokens[$closeBracket]['line']) { // Closing brace needs to be indented to the same level // as the function call. $inArg = false; $expectedIndent = ($foundFunctionIndent + $adjustment); } else { $expectedIndent = ($foundFunctionIndent + $this->indent + $adjustment); } if ($tokens[$i]['code'] !== T_WHITESPACE && $tokens[$i]['code'] !== T_DOC_COMMENT_WHITESPACE ) { // Just check if it is a multi-line block comment. If so, we can // calculate the indent from the whitespace before the content. if ($tokens[$i]['code'] === T_COMMENT && $tokens[($i - 1)]['code'] === T_COMMENT ) { $trimmedLength = strlen(ltrim($tokens[$i]['content'])); if ($trimmedLength === 0) { // This is a blank comment line, so indenting it is // pointless. continue; } $foundIndent = (strlen($tokens[$i]['content']) - $trimmedLength); } else { $foundIndent = 0; } } else { $foundIndent = $tokens[$i]['length']; } if ($foundIndent < $expectedIndent || ($inArg === false && $expectedIndent !== $foundIndent) ) { $error = 'Multi-line function call not indented correctly; expected %s spaces but found %s'; $data = [ $expectedIndent, $foundIndent, ]; $fix = $phpcsFile->addFixableError($error, $i, 'Indent', $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $padding = str_repeat(' ', $expectedIndent); if ($foundIndent === 0) { $phpcsFile->fixer->addContentBefore($i, $padding); if (isset($tokens[$i]['scope_opener']) === true) { $phpcsFile->fixer->changeCodeBlockIndent($i, $tokens[$i]['scope_closer'], $expectedIndent); } } else { if ($tokens[$i]['code'] === T_COMMENT) { $comment = $padding.ltrim($tokens[$i]['content']); $phpcsFile->fixer->replaceToken($i, $comment); } else { $phpcsFile->fixer->replaceToken($i, $padding); } if (isset($tokens[($i + 1)]['scope_opener']) === true) { $phpcsFile->fixer->changeCodeBlockIndent(($i + 1), $tokens[($i + 1)]['scope_closer'], ($expectedIndent - $foundIndent)); } } $phpcsFile->fixer->endChangeset(); }//end if }//end if } else { $nextCode = $i; }//end if if ($inArg === false) { $argStart = $nextCode; $argEnd = $phpcsFile->findEndOfStatement($nextCode); } }//end if // If we are within an argument we should be ignoring commas // as these are not signalling the end of an argument. if ($inArg === false && $tokens[$i]['code'] === T_COMMA) { $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($i + 1), $closeBracket, true); if ($next === false) { continue; } if ($this->allowMultipleArguments === false) { // Comma has to be the last token on the line. if ($tokens[$i]['line'] === $tokens[$next]['line']) { $error = 'Only one argument is allowed per line in a multi-line function call'; $fix = $phpcsFile->addFixableError($error, $next, 'MultipleArguments'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($x = ($next - 1); $x > $i; $x--) { if ($tokens[$x]['code'] !== T_WHITESPACE) { break; } $phpcsFile->fixer->replaceToken($x, ''); } $phpcsFile->fixer->addContentBefore( $next, $phpcsFile->eolChar.str_repeat(' ', ($foundFunctionIndent + $this->indent)) ); $phpcsFile->fixer->endChangeset(); } } }//end if $argStart = $next; $argEnd = $phpcsFile->findEndOfStatement($next); }//end if }//end for }//end processMultiLineCall() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Sniffs/Functions/FunctionDeclarationSniff.php0000644000076500000240000005150713614652361030417 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Sniffs\Functions; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Standards\Generic\Sniffs\Functions\OpeningFunctionBraceBsdAllmanSniff; use PHP_CodeSniffer\Standards\Generic\Sniffs\Functions\OpeningFunctionBraceKernighanRitchieSniff; use PHP_CodeSniffer\Util\Tokens; class FunctionDeclarationSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * The number of spaces code should be indented. * * @var integer */ public $indent = 4; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_FUNCTION, T_CLOSURE, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['parenthesis_opener']) === false || isset($tokens[$stackPtr]['parenthesis_closer']) === false || $tokens[$stackPtr]['parenthesis_opener'] === null || $tokens[$stackPtr]['parenthesis_closer'] === null ) { return; } $openBracket = $tokens[$stackPtr]['parenthesis_opener']; $closeBracket = $tokens[$stackPtr]['parenthesis_closer']; if (strtolower($tokens[$stackPtr]['content']) === 'function') { // Must be one space after the FUNCTION keyword. if ($tokens[($stackPtr + 1)]['content'] === $phpcsFile->eolChar) { $spaces = 'newline'; } else if ($tokens[($stackPtr + 1)]['code'] === T_WHITESPACE) { $spaces = $tokens[($stackPtr + 1)]['length']; } else { $spaces = 0; } if ($spaces !== 1) { $error = 'Expected 1 space after FUNCTION keyword; %s found'; $data = [$spaces]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceAfterFunction', $data); if ($fix === true) { if ($spaces === 0) { $phpcsFile->fixer->addContent($stackPtr, ' '); } else { $phpcsFile->fixer->replaceToken(($stackPtr + 1), ' '); } } } }//end if // Must be no space before the opening parenthesis. For closures, this is // enforced by the previous check because there is no content between the keywords // and the opening parenthesis. // Unfinished closures are tokenized as T_FUNCTION however, and can be excluded // by checking for the scope_opener. if ($tokens[$stackPtr]['code'] === T_FUNCTION && (isset($tokens[$stackPtr]['scope_opener']) === true || $phpcsFile->getMethodProperties($stackPtr)['has_body'] === false) ) { if ($tokens[($openBracket - 1)]['content'] === $phpcsFile->eolChar) { $spaces = 'newline'; } else if ($tokens[($openBracket - 1)]['code'] === T_WHITESPACE) { $spaces = $tokens[($openBracket - 1)]['length']; } else { $spaces = 0; } if ($spaces !== 0) { $error = 'Expected 0 spaces before opening parenthesis; %s found'; $data = [$spaces]; $fix = $phpcsFile->addFixableError($error, $openBracket, 'SpaceBeforeOpenParen', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($openBracket - 1), ''); } } // Must be no space before semicolon in abstract/interface methods. if ($phpcsFile->getMethodProperties($stackPtr)['has_body'] === false) { $end = $phpcsFile->findNext(T_SEMICOLON, $closeBracket); if ($tokens[($end - 1)]['content'] === $phpcsFile->eolChar) { $spaces = 'newline'; } else if ($tokens[($end - 1)]['code'] === T_WHITESPACE) { $spaces = $tokens[($end - 1)]['length']; } else { $spaces = 0; } if ($spaces !== 0) { $error = 'Expected 0 spaces before semicolon; %s found'; $data = [$spaces]; $fix = $phpcsFile->addFixableError($error, $end, 'SpaceBeforeSemicolon', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($end - 1), ''); } } } }//end if // Must be one space before and after USE keyword for closures. if ($tokens[$stackPtr]['code'] === T_CLOSURE) { $use = $phpcsFile->findNext(T_USE, ($closeBracket + 1), $tokens[$stackPtr]['scope_opener']); if ($use !== false) { if ($tokens[($use + 1)]['code'] !== T_WHITESPACE) { $length = 0; } else if ($tokens[($use + 1)]['content'] === "\t") { $length = '\t'; } else { $length = $tokens[($use + 1)]['length']; } if ($length !== 1) { $error = 'Expected 1 space after USE keyword; found %s'; $data = [$length]; $fix = $phpcsFile->addFixableError($error, $use, 'SpaceAfterUse', $data); if ($fix === true) { if ($length === 0) { $phpcsFile->fixer->addContent($use, ' '); } else { $phpcsFile->fixer->replaceToken(($use + 1), ' '); } } } if ($tokens[($use - 1)]['code'] !== T_WHITESPACE) { $length = 0; } else if ($tokens[($use - 1)]['content'] === "\t") { $length = '\t'; } else { $length = $tokens[($use - 1)]['length']; } if ($length !== 1) { $error = 'Expected 1 space before USE keyword; found %s'; $data = [$length]; $fix = $phpcsFile->addFixableError($error, $use, 'SpaceBeforeUse', $data); if ($fix === true) { if ($length === 0) { $phpcsFile->fixer->addContentBefore($use, ' '); } else { $phpcsFile->fixer->replaceToken(($use - 1), ' '); } } } }//end if }//end if if ($this->isMultiLineDeclaration($phpcsFile, $stackPtr, $openBracket, $tokens) === true) { $this->processMultiLineDeclaration($phpcsFile, $stackPtr, $tokens); } else { $this->processSingleLineDeclaration($phpcsFile, $stackPtr, $tokens); } }//end process() /** * Determine if this is a multi-line function declaration. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param int $openBracket The position of the opening bracket * in the stack passed in $tokens. * @param array $tokens The stack of tokens that make up * the file. * * @return bool */ public function isMultiLineDeclaration($phpcsFile, $stackPtr, $openBracket, $tokens) { $closeBracket = $tokens[$openBracket]['parenthesis_closer']; if ($tokens[$openBracket]['line'] !== $tokens[$closeBracket]['line']) { return true; } // Closures may use the USE keyword and so be multi-line in this way. if ($tokens[$stackPtr]['code'] === T_CLOSURE) { $use = $phpcsFile->findNext(T_USE, ($closeBracket + 1), $tokens[$stackPtr]['scope_opener']); if ($use !== false) { // If the opening and closing parenthesis of the use statement // are also on the same line, this is a single line declaration. $open = $phpcsFile->findNext(T_OPEN_PARENTHESIS, ($use + 1)); $close = $tokens[$open]['parenthesis_closer']; if ($tokens[$open]['line'] !== $tokens[$close]['line']) { return true; } } } return false; }//end isMultiLineDeclaration() /** * Processes single-line declarations. * * Just uses the Generic BSD-Allman brace sniff. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param array $tokens The stack of tokens that make up * the file. * * @return void */ public function processSingleLineDeclaration($phpcsFile, $stackPtr, $tokens) { if ($tokens[$stackPtr]['code'] === T_CLOSURE) { $sniff = new OpeningFunctionBraceKernighanRitchieSniff(); } else { $sniff = new OpeningFunctionBraceBsdAllmanSniff(); } $sniff->checkClosures = true; $sniff->process($phpcsFile, $stackPtr); }//end processSingleLineDeclaration() /** * Processes multi-line declarations. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param array $tokens The stack of tokens that make up * the file. * * @return void */ public function processMultiLineDeclaration($phpcsFile, $stackPtr, $tokens) { $this->processArgumentList($phpcsFile, $stackPtr, $this->indent); $closeBracket = $tokens[$stackPtr]['parenthesis_closer']; if ($tokens[$stackPtr]['code'] === T_CLOSURE) { $use = $phpcsFile->findNext(T_USE, ($closeBracket + 1), $tokens[$stackPtr]['scope_opener']); if ($use !== false) { $open = $phpcsFile->findNext(T_OPEN_PARENTHESIS, ($use + 1)); $closeBracket = $tokens[$open]['parenthesis_closer']; } } if (isset($tokens[$stackPtr]['scope_opener']) === false) { return; } // The opening brace needs to be one space away from the closing parenthesis. $opener = $tokens[$stackPtr]['scope_opener']; if ($tokens[$opener]['line'] !== $tokens[$closeBracket]['line']) { $error = 'The closing parenthesis and the opening brace of a multi-line function declaration must be on the same line'; $fix = $phpcsFile->addFixableError($error, $opener, 'NewlineBeforeOpenBrace'); if ($fix === true) { $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($opener - 1), $closeBracket, true); $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->addContent($prev, ' {'); // If the opener is on a line by itself, removing it will create // an empty line, so just remove the entire line instead. $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($opener - 1), $closeBracket, true); $next = $phpcsFile->findNext(T_WHITESPACE, ($opener + 1), null, true); if ($tokens[$prev]['line'] < $tokens[$opener]['line'] && $tokens[$next]['line'] > $tokens[$opener]['line'] ) { // Clear the whole line. for ($i = ($prev + 1); $i < $next; $i++) { if ($tokens[$i]['line'] === $tokens[$opener]['line']) { $phpcsFile->fixer->replaceToken($i, ''); } } } else { // Just remove the opener. $phpcsFile->fixer->replaceToken($opener, ''); if ($tokens[$next]['line'] === $tokens[$opener]['line']) { $phpcsFile->fixer->replaceToken(($opener + 1), ''); } } $phpcsFile->fixer->endChangeset(); }//end if } else { $prev = $tokens[($opener - 1)]; if ($prev['code'] !== T_WHITESPACE) { $length = 0; } else { $length = strlen($prev['content']); } if ($length !== 1) { $error = 'There must be a single space between the closing parenthesis and the opening brace of a multi-line function declaration; found %s spaces'; $fix = $phpcsFile->addFixableError($error, ($opener - 1), 'SpaceBeforeOpenBrace', [$length]); if ($fix === true) { if ($length === 0) { $phpcsFile->fixer->addContentBefore($opener, ' '); } else { $phpcsFile->fixer->replaceToken(($opener - 1), ' '); } } return; }//end if }//end if }//end processMultiLineDeclaration() /** * Processes multi-line argument list declarations. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param int $indent The number of spaces code should be indented. * @param string $type The type of the token the brackets * belong to. * * @return void */ public function processArgumentList($phpcsFile, $stackPtr, $indent, $type='function') { $tokens = $phpcsFile->getTokens(); // We need to work out how far indented the function // declaration itself is, so we can work out how far to // indent parameters. $functionIndent = 0; for ($i = ($stackPtr - 1); $i >= 0; $i--) { if ($tokens[$i]['line'] !== $tokens[$stackPtr]['line']) { break; } } // Move $i back to the line the function is or to 0. $i++; if ($tokens[$i]['code'] === T_WHITESPACE) { $functionIndent = $tokens[$i]['length']; } // The closing parenthesis must be on a new line, even // when checking abstract function definitions. $closeBracket = $tokens[$stackPtr]['parenthesis_closer']; $prev = $phpcsFile->findPrevious( T_WHITESPACE, ($closeBracket - 1), null, true ); if ($tokens[$closeBracket]['line'] !== $tokens[$tokens[$closeBracket]['parenthesis_opener']]['line'] && $tokens[$prev]['line'] === $tokens[$closeBracket]['line'] ) { $error = 'The closing parenthesis of a multi-line '.$type.' declaration must be on a new line'; $fix = $phpcsFile->addFixableError($error, $closeBracket, 'CloseBracketLine'); if ($fix === true) { $phpcsFile->fixer->addNewlineBefore($closeBracket); } } // If this is a closure and is using a USE statement, the closing // parenthesis we need to look at from now on is the closing parenthesis // of the USE statement. if ($tokens[$stackPtr]['code'] === T_CLOSURE) { $use = $phpcsFile->findNext(T_USE, ($closeBracket + 1), $tokens[$stackPtr]['scope_opener']); if ($use !== false) { $open = $phpcsFile->findNext(T_OPEN_PARENTHESIS, ($use + 1)); $closeBracket = $tokens[$open]['parenthesis_closer']; $prev = $phpcsFile->findPrevious( T_WHITESPACE, ($closeBracket - 1), null, true ); if ($tokens[$closeBracket]['line'] !== $tokens[$tokens[$closeBracket]['parenthesis_opener']]['line'] && $tokens[$prev]['line'] === $tokens[$closeBracket]['line'] ) { $error = 'The closing parenthesis of a multi-line use declaration must be on a new line'; $fix = $phpcsFile->addFixableError($error, $closeBracket, 'UseCloseBracketLine'); if ($fix === true) { $phpcsFile->fixer->addNewlineBefore($closeBracket); } } }//end if }//end if // Each line between the parenthesis should be indented 4 spaces. $openBracket = $tokens[$stackPtr]['parenthesis_opener']; $lastLine = $tokens[$openBracket]['line']; for ($i = ($openBracket + 1); $i < $closeBracket; $i++) { if ($tokens[$i]['line'] !== $lastLine) { if ($i === $tokens[$stackPtr]['parenthesis_closer'] || ($tokens[$i]['code'] === T_WHITESPACE && (($i + 1) === $closeBracket || ($i + 1) === $tokens[$stackPtr]['parenthesis_closer'])) ) { // Closing braces need to be indented to the same level // as the function. $expectedIndent = $functionIndent; } else { $expectedIndent = ($functionIndent + $indent); } // We changed lines, so this should be a whitespace indent token. if ($tokens[$i]['code'] !== T_WHITESPACE) { $foundIndent = 0; } else if ($tokens[$i]['line'] !== $tokens[($i + 1)]['line']) { // This is an empty line, so don't check the indent. $foundIndent = $expectedIndent; $error = 'Blank lines are not allowed in a multi-line '.$type.' declaration'; $fix = $phpcsFile->addFixableError($error, $i, 'EmptyLine'); if ($fix === true) { $phpcsFile->fixer->replaceToken($i, ''); } } else { $foundIndent = $tokens[$i]['length']; } if ($expectedIndent !== $foundIndent) { $error = 'Multi-line '.$type.' declaration not indented correctly; expected %s spaces but found %s'; $data = [ $expectedIndent, $foundIndent, ]; $fix = $phpcsFile->addFixableError($error, $i, 'Indent', $data); if ($fix === true) { $spaces = str_repeat(' ', $expectedIndent); if ($foundIndent === 0) { $phpcsFile->fixer->addContentBefore($i, $spaces); } else { $phpcsFile->fixer->replaceToken($i, $spaces); } } } $lastLine = $tokens[$i]['line']; }//end if if ($tokens[$i]['code'] === T_ARRAY || $tokens[$i]['code'] === T_OPEN_SHORT_ARRAY) { // Skip arrays as they have their own indentation rules. if ($tokens[$i]['code'] === T_OPEN_SHORT_ARRAY) { $i = $tokens[$i]['bracket_closer']; } else { $i = $tokens[$i]['parenthesis_closer']; } $lastLine = $tokens[$i]['line']; continue; } }//end for }//end processArgumentList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Sniffs/Functions/ValidDefaultValueSniff.php0000644000076500000240000000446413614652361030025 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Sniffs\Functions; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class ValidDefaultValueSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return int[] */ public function register() { return [ T_FUNCTION, T_CLOSURE, T_FN, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { // Flag for when we have found a default in our arg list. // If there is a value without a default after this, it is an error. $defaultFound = false; $params = $phpcsFile->getMethodParameters($stackPtr); foreach ($params as $param) { if ($param['variable_length'] === true) { continue; } if (array_key_exists('default', $param) === true) { $defaultFound = true; // Check if the arg is type hinted and using NULL for the default. // This does not make the argument optional - it just allows NULL // to be passed in. if ($param['type_hint'] !== '' && strtolower($param['default']) === 'null') { $defaultFound = false; } continue; } if ($defaultFound === true) { $error = 'Arguments with default values must be at the end of the argument list'; $phpcsFile->addError($error, $param['token'], 'NotAtEnd'); return; } }//end foreach }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Sniffs/NamingConventions/ValidClassNameSniff.php0000644000076500000240000000615113614652361030774 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Sniffs\NamingConventions; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class ValidClassNameSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_CLASS, T_INTERFACE, T_TRAIT, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being processed. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $className = $phpcsFile->findNext(T_STRING, $stackPtr); $name = trim($tokens[$className]['content']); $errorData = [ucfirst($tokens[$stackPtr]['content'])]; // Make sure the first letter is a capital. if (preg_match('|^[A-Z]|', $name) === 0) { $error = '%s name must begin with a capital letter'; $phpcsFile->addError($error, $stackPtr, 'StartWithCapital', $errorData); } // Check that each new word starts with a capital as well, but don't // check the first word, as it is checked above. $validName = true; $nameBits = explode('_', $name); $firstBit = array_shift($nameBits); foreach ($nameBits as $bit) { if ($bit === '' || $bit[0] !== strtoupper($bit[0])) { $validName = false; break; } } if ($validName === false) { // Strip underscores because they cause the suggested name // to be incorrect. $nameBits = explode('_', trim($name, '_')); $firstBit = array_shift($nameBits); if ($firstBit === '') { $error = '%s name is not valid'; $phpcsFile->addError($error, $stackPtr, 'Invalid', $errorData); } else { $newName = strtoupper($firstBit[0]).substr($firstBit, 1).'_'; foreach ($nameBits as $bit) { if ($bit !== '') { $newName .= strtoupper($bit[0]).substr($bit, 1).'_'; } } $newName = rtrim($newName, '_'); $error = '%s name is not valid; consider %s instead'; $data = $errorData; $data[] = $newName; $phpcsFile->addError($error, $stackPtr, 'Invalid', $data); } }//end if }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Sniffs/NamingConventions/ValidFunctionNameSniff.php0000644000076500000240000002335413614652361031520 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Sniffs\NamingConventions; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\AbstractScopeSniff; use PHP_CodeSniffer\Util\Common; use PHP_CodeSniffer\Util\Tokens; class ValidFunctionNameSniff extends AbstractScopeSniff { /** * A list of all PHP magic methods. * * @var array */ protected $magicMethods = [ 'construct' => true, 'destruct' => true, 'call' => true, 'callstatic' => true, 'get' => true, 'set' => true, 'isset' => true, 'unset' => true, 'sleep' => true, 'wakeup' => true, 'tostring' => true, 'set_state' => true, 'clone' => true, 'invoke' => true, 'debuginfo' => true, ]; /** * A list of all PHP magic functions. * * @var array */ protected $magicFunctions = ['autoload' => true]; /** * Constructs a PEAR_Sniffs_NamingConventions_ValidFunctionNameSniff. */ public function __construct() { parent::__construct(Tokens::$ooScopeTokens, [T_FUNCTION], true); }//end __construct() /** * Processes the tokens within the scope. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being processed. * @param int $stackPtr The position where this token was * found. * @param int $currScope The position of the current scope. * * @return void */ protected function processTokenWithinScope(File $phpcsFile, $stackPtr, $currScope) { $tokens = $phpcsFile->getTokens(); // Determine if this is a function which needs to be examined. $conditions = $tokens[$stackPtr]['conditions']; end($conditions); $deepestScope = key($conditions); if ($deepestScope !== $currScope) { return; } $methodName = $phpcsFile->getDeclarationName($stackPtr); if ($methodName === null) { // Ignore closures. return; } $className = $phpcsFile->getDeclarationName($currScope); if (isset($className) === false) { $className = '[Anonymous Class]'; } $errorData = [$className.'::'.$methodName]; $methodNameLc = strtolower($methodName); $classNameLc = strtolower($className); // Is this a magic method. i.e., is prefixed with "__" ? if (preg_match('|^__[^_]|', $methodName) !== 0) { $magicPart = substr($methodNameLc, 2); if (isset($this->magicMethods[$magicPart]) === true) { return; } $error = 'Method name "%s" is invalid; only PHP magic methods should be prefixed with a double underscore'; $phpcsFile->addError($error, $stackPtr, 'MethodDoubleUnderscore', $errorData); } // PHP4 constructors are allowed to break our rules. if ($methodNameLc === $classNameLc) { return; } // PHP4 destructors are allowed to break our rules. if ($methodNameLc === '_'.$classNameLc) { return; } $methodProps = $phpcsFile->getMethodProperties($stackPtr); $scope = $methodProps['scope']; $scopeSpecified = $methodProps['scope_specified']; if ($methodProps['scope'] === 'private') { $isPublic = false; } else { $isPublic = true; } // If it's a private method, it must have an underscore on the front. if ($isPublic === false) { if ($methodName[0] !== '_') { $error = 'Private method name "%s" must be prefixed with an underscore'; $phpcsFile->addError($error, $stackPtr, 'PrivateNoUnderscore', $errorData); $phpcsFile->recordMetric($stackPtr, 'Private method prefixed with underscore', 'no'); } else { $phpcsFile->recordMetric($stackPtr, 'Private method prefixed with underscore', 'yes'); } } // If it's not a private method, it must not have an underscore on the front. if ($isPublic === true && $scopeSpecified === true && $methodName[0] === '_') { $error = '%s method name "%s" must not be prefixed with an underscore'; $data = [ ucfirst($scope), $errorData[0], ]; $phpcsFile->addError($error, $stackPtr, 'PublicUnderscore', $data); } $testMethodName = ltrim($methodName, '_'); if (Common::isCamelCaps($testMethodName, false, true, false) === false) { if ($scopeSpecified === true) { $error = '%s method name "%s" is not in camel caps format'; $data = [ ucfirst($scope), $errorData[0], ]; $phpcsFile->addError($error, $stackPtr, 'ScopeNotCamelCaps', $data); } else { $error = 'Method name "%s" is not in camel caps format'; $phpcsFile->addError($error, $stackPtr, 'NotCamelCaps', $errorData); } } }//end processTokenWithinScope() /** * Processes the tokens outside the scope. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being processed. * @param int $stackPtr The position where this token was * found. * * @return void */ protected function processTokenOutsideScope(File $phpcsFile, $stackPtr) { $functionName = $phpcsFile->getDeclarationName($stackPtr); if ($functionName === null) { // Ignore closures. return; } if (ltrim($functionName, '_') === '') { // Ignore special functions. return; } $errorData = [$functionName]; // Is this a magic function. i.e., it is prefixed with "__". if (preg_match('|^__[^_]|', $functionName) !== 0) { $magicPart = strtolower(substr($functionName, 2)); if (isset($this->magicFunctions[$magicPart]) === true) { return; } $error = 'Function name "%s" is invalid; only PHP magic methods should be prefixed with a double underscore'; $phpcsFile->addError($error, $stackPtr, 'FunctionDoubleUnderscore', $errorData); } // Function names can be in two parts; the package name and // the function name. $packagePart = ''; $underscorePos = strrpos($functionName, '_'); if ($underscorePos === false) { $camelCapsPart = $functionName; } else { $packagePart = substr($functionName, 0, $underscorePos); $camelCapsPart = substr($functionName, ($underscorePos + 1)); // We don't care about _'s on the front. $packagePart = ltrim($packagePart, '_'); } // If it has a package part, make sure the first letter is a capital. if ($packagePart !== '') { if ($functionName[0] === '_') { $error = 'Function name "%s" is invalid; only private methods should be prefixed with an underscore'; $phpcsFile->addError($error, $stackPtr, 'FunctionUnderscore', $errorData); } if ($functionName[0] !== strtoupper($functionName[0])) { $error = 'Function name "%s" is prefixed with a package name but does not begin with a capital letter'; $phpcsFile->addError($error, $stackPtr, 'FunctionNoCapital', $errorData); } } // If it doesn't have a camel caps part, it's not valid. if (trim($camelCapsPart) === '') { $error = 'Function name "%s" is not valid; name appears incomplete'; $phpcsFile->addError($error, $stackPtr, 'FunctionInvalid', $errorData); return; } $validName = true; $newPackagePart = $packagePart; $newCamelCapsPart = $camelCapsPart; // Every function must have a camel caps part, so check that first. if (Common::isCamelCaps($camelCapsPart, false, true, false) === false) { $validName = false; $newCamelCapsPart = strtolower($camelCapsPart[0]).substr($camelCapsPart, 1); } if ($packagePart !== '') { // Check that each new word starts with a capital. $nameBits = explode('_', $packagePart); $nameBits = array_filter($nameBits); foreach ($nameBits as $bit) { if ($bit[0] !== strtoupper($bit[0])) { $newPackagePart = ''; foreach ($nameBits as $bit) { $newPackagePart .= strtoupper($bit[0]).substr($bit, 1).'_'; } $validName = false; break; } } } if ($validName === false) { if ($newPackagePart === '') { $newName = $newCamelCapsPart; } else { $newName = rtrim($newPackagePart, '_').'_'.$newCamelCapsPart; } $error = 'Function name "%s" is invalid; consider "%s" instead'; $data = $errorData; $data[] = $newName; $phpcsFile->addError($error, $stackPtr, 'FunctionNameInvalid', $data); } }//end processTokenOutsideScope() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Sniffs/NamingConventions/ValidVariableNameSniff.php0000644000076500000240000000622013614652361031451 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Sniffs\NamingConventions; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\AbstractVariableSniff; class ValidVariableNameSniff extends AbstractVariableSniff { /** * Processes class member variables. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ protected function processMemberVar(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $memberProps = $phpcsFile->getMemberProperties($stackPtr); if (empty($memberProps) === true) { return; } $memberName = ltrim($tokens[$stackPtr]['content'], '$'); $scope = $memberProps['scope']; $scopeSpecified = $memberProps['scope_specified']; if ($memberProps['scope'] === 'private') { $isPublic = false; } else { $isPublic = true; } // If it's a private member, it must have an underscore on the front. if ($isPublic === false && $memberName[0] !== '_') { $error = 'Private member variable "%s" must be prefixed with an underscore'; $data = [$memberName]; $phpcsFile->addError($error, $stackPtr, 'PrivateNoUnderscore', $data); return; } // If it's not a private member, it must not have an underscore on the front. if ($isPublic === true && $scopeSpecified === true && $memberName[0] === '_') { $error = '%s member variable "%s" must not be prefixed with an underscore'; $data = [ ucfirst($scope), $memberName, ]; $phpcsFile->addError($error, $stackPtr, 'PublicUnderscore', $data); return; } }//end processMemberVar() /** * Processes normal variables. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param int $stackPtr The position where the token was found. * * @return void */ protected function processVariable(File $phpcsFile, $stackPtr) { /* We don't care about normal variables. */ }//end processVariable() /** * Processes variables in double quoted strings. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param int $stackPtr The position where the token was found. * * @return void */ protected function processVariableInString(File $phpcsFile, $stackPtr) { /* We don't care about normal variables. */ }//end processVariableInString() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Sniffs/WhiteSpace/ObjectOperatorIndentSniff.php0000644000076500000240000001540513614652361030631 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Sniffs\WhiteSpace; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class ObjectOperatorIndentSniff implements Sniff { /** * The number of spaces code should be indented. * * @var integer */ public $indent = 4; /** * Indicates whether multilevel indenting is allowed. * * @var boolean */ public $multilevel = false; /** * Returns an array of tokens this test wants to listen for. * * @return int[] */ public function register() { return [T_OBJECT_OPERATOR]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile All the tokens found in the document. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Make sure this is the first object operator in a chain of them. $start = $phpcsFile->findStartOfStatement($stackPtr); $prev = $phpcsFile->findPrevious(T_OBJECT_OPERATOR, ($stackPtr - 1), $start); if ($prev !== false) { return; } // Make sure this is a chained call. $end = $phpcsFile->findEndOfStatement($stackPtr); $next = $phpcsFile->findNext(T_OBJECT_OPERATOR, ($stackPtr + 1), $end); if ($next === false) { // Not a chained call. return; } // Determine correct indent. for ($i = ($start - 1); $i >= 0; $i--) { if ($tokens[$i]['line'] !== $tokens[$start]['line']) { $i++; break; } } $baseIndent = 0; if ($i >= 0 && $tokens[$i]['code'] === T_WHITESPACE) { $baseIndent = $tokens[$i]['length']; } $baseIndent += $this->indent; // Determine the scope of the original object operator. $origBrackets = null; if (isset($tokens[$stackPtr]['nested_parenthesis']) === true) { $origBrackets = $tokens[$stackPtr]['nested_parenthesis']; } $origConditions = null; if (isset($tokens[$stackPtr]['conditions']) === true) { $origConditions = $tokens[$stackPtr]['conditions']; } // Check indentation of each object operator in the chain. // If the first object operator is on a different line than // the variable, make sure we check its indentation too. if ($tokens[$stackPtr]['line'] > $tokens[$start]['line']) { $next = $stackPtr; } $previousIndent = $baseIndent; while ($next !== false) { // Make sure it is in the same scope, otherwise don't check indent. $brackets = null; if (isset($tokens[$next]['nested_parenthesis']) === true) { $brackets = $tokens[$next]['nested_parenthesis']; } $conditions = null; if (isset($tokens[$next]['conditions']) === true) { $conditions = $tokens[$next]['conditions']; } if ($origBrackets === $brackets && $origConditions === $conditions) { // Make sure it starts a line, otherwise don't check indent. $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($next - 1), $stackPtr, true); $indent = $tokens[($next - 1)]; if ($tokens[$prev]['line'] !== $tokens[$next]['line'] && $indent['code'] === T_WHITESPACE ) { if ($indent['line'] === $tokens[$next]['line']) { $foundIndent = strlen($indent['content']); } else { $foundIndent = 0; } $minIndent = $previousIndent; $maxIndent = $previousIndent; $expectedIndent = $previousIndent; if ($this->multilevel === true) { $minIndent = max(($previousIndent - $this->indent), $baseIndent); $maxIndent = ($previousIndent + $this->indent); $expectedIndent = min(max($foundIndent, $minIndent), $maxIndent); } if ($foundIndent < $minIndent || $foundIndent > $maxIndent) { $error = 'Object operator not indented correctly; expected %s spaces but found %s'; $data = [ $expectedIndent, $foundIndent, ]; $fix = $phpcsFile->addFixableError($error, $next, 'Incorrect', $data); if ($fix === true) { $spaces = str_repeat(' ', $expectedIndent); if ($foundIndent === 0) { $phpcsFile->fixer->addContentBefore($next, $spaces); } else { $phpcsFile->fixer->replaceToken(($next - 1), $spaces); } } } $previousIndent = $expectedIndent; }//end if // It cant be the last thing on the line either. $content = $phpcsFile->findNext(T_WHITESPACE, ($next + 1), null, true); if ($tokens[$content]['line'] !== $tokens[$next]['line']) { $error = 'Object operator must be at the start of the line, not the end'; $fix = $phpcsFile->addFixableError($error, $next, 'StartOfLine'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($x = ($next + 1); $x < $content; $x++) { $phpcsFile->fixer->replaceToken($x, ''); } $phpcsFile->fixer->addNewlineBefore($next); $phpcsFile->fixer->endChangeset(); } } }//end if $next = $phpcsFile->findNext( T_OBJECT_OPERATOR, ($next + 1), null, false, null, true ); }//end while }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Sniffs/WhiteSpace/ScopeClosingBraceSniff.php0000644000076500000240000001417713614652361030077 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Sniffs\WhiteSpace; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class ScopeClosingBraceSniff implements Sniff { /** * The number of spaces code should be indented. * * @var integer */ public $indent = 4; /** * Returns an array of tokens this test wants to listen for. * * @return int[] */ public function register() { return Tokens::$scopeOpeners; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile All the tokens found in the document. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // If this is an inline condition (ie. there is no scope opener), then // return, as this is not a new scope. if (isset($tokens[$stackPtr]['scope_closer']) === false) { return; } $scopeStart = $tokens[$stackPtr]['scope_opener']; $scopeEnd = $tokens[$stackPtr]['scope_closer']; // If the scope closer doesn't think it belongs to this scope opener // then the opener is sharing its closer with other tokens. We only // want to process the closer once, so skip this one. if (isset($tokens[$scopeEnd]['scope_condition']) === false || $tokens[$scopeEnd]['scope_condition'] !== $stackPtr ) { return; } // We need to actually find the first piece of content on this line, // because if this is a method with tokens before it (public, static etc) // or an if with an else before it, then we need to start the scope // checking from there, rather than the current token. $lineStart = ($stackPtr - 1); for ($lineStart; $lineStart > 0; $lineStart--) { if (strpos($tokens[$lineStart]['content'], $phpcsFile->eolChar) !== false) { break; } } $lineStart++; $startColumn = 1; if ($tokens[$lineStart]['code'] === T_WHITESPACE) { $startColumn = $tokens[($lineStart + 1)]['column']; } else if ($tokens[$lineStart]['code'] === T_INLINE_HTML) { $trimmed = ltrim($tokens[$lineStart]['content']); if ($trimmed === '') { $startColumn = $tokens[($lineStart + 1)]['column']; } else { $startColumn = (strlen($tokens[$lineStart]['content']) - strlen($trimmed)); } } // Check that the closing brace is on it's own line. $lastContent = $phpcsFile->findPrevious( [ T_WHITESPACE, T_INLINE_HTML, T_OPEN_TAG, ], ($scopeEnd - 1), $scopeStart, true ); if ($tokens[$lastContent]['line'] === $tokens[$scopeEnd]['line']) { $error = 'Closing brace must be on a line by itself'; $fix = $phpcsFile->addFixableError($error, $scopeEnd, 'Line'); if ($fix === true) { $phpcsFile->fixer->addNewlineBefore($scopeEnd); } return; } // Check now that the closing brace is lined up correctly. $lineStart = ($scopeEnd - 1); for ($lineStart; $lineStart > 0; $lineStart--) { if (strpos($tokens[$lineStart]['content'], $phpcsFile->eolChar) !== false) { break; } } $lineStart++; $braceIndent = 0; if ($tokens[$lineStart]['code'] === T_WHITESPACE) { $braceIndent = ($tokens[($lineStart + 1)]['column'] - 1); } else if ($tokens[$lineStart]['code'] === T_INLINE_HTML) { $trimmed = ltrim($tokens[$lineStart]['content']); if ($trimmed === '') { $braceIndent = ($tokens[($lineStart + 1)]['column'] - 1); } else { $braceIndent = (strlen($tokens[$lineStart]['content']) - strlen($trimmed) - 1); } } $fix = false; if ($tokens[$stackPtr]['code'] === T_CASE || $tokens[$stackPtr]['code'] === T_DEFAULT ) { // BREAK statements should be indented n spaces from the // CASE or DEFAULT statement. $expectedIndent = ($startColumn + $this->indent - 1); if ($braceIndent !== $expectedIndent) { $error = 'Case breaking statement indented incorrectly; expected %s spaces, found %s'; $data = [ $expectedIndent, $braceIndent, ]; $fix = $phpcsFile->addFixableError($error, $scopeEnd, 'BreakIndent', $data); } } else { $expectedIndent = max(0, ($startColumn - 1)); if ($braceIndent !== $expectedIndent) { $error = 'Closing brace indented incorrectly; expected %s spaces, found %s'; $data = [ $expectedIndent, $braceIndent, ]; $fix = $phpcsFile->addFixableError($error, $scopeEnd, 'Indent', $data); } }//end if if ($fix === true) { $spaces = str_repeat(' ', $expectedIndent); if ($braceIndent === 0) { $phpcsFile->fixer->addContentBefore($lineStart, $spaces); } else { $phpcsFile->fixer->replaceToken($lineStart, ltrim($tokens[$lineStart]['content'])); $phpcsFile->fixer->addContentBefore($lineStart, $spaces); } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Sniffs/WhiteSpace/ScopeIndentSniff.php0000644000076500000240000000124513614652361026755 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Sniffs\WhiteSpace; use PHP_CodeSniffer\Standards\Generic\Sniffs\WhiteSpace\ScopeIndentSniff as GenericScopeIndentSniff; class ScopeIndentSniff extends GenericScopeIndentSniff { /** * Any scope openers that should not cause an indent. * * @var int[] */ protected $nonIndentingScopes = [T_SWITCH]; }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/Classes/ClassDeclarationUnitTest.1.inc0000644000076500000240000000407013614652361030022 0ustar gsherwoodstaffsetLogger(new class {}); var_dump(new class(10) extends SomeClass implements SomeInterface { private $num; public function __construct($num) { $this->num = $num; } use SomeTrait; }); class IncorrectClassDeclarationWithCommentAtEnd extends correctClassDeclaration /* Comment */ { } class CorrectClassDeclarationWithCommentAtEnd extends correctClassDeclaration /* Comment */ { } // Don't move phpcs:ignore comments. class PHPCSIgnoreAnnotationAfterOpeningBrace { // phpcs:ignore Standard.Cat.Sniff -- for reasons. } // Moving any of the other trailing phpcs: comments is ok. class PHPCSAnnotationAfterOpeningBrace { // phpcs:disable Standard.Cat.Sniff -- for reasons. } if (!class_exists('ClassOpeningBraceShouldBeIndented')) { abstract class ClassOpeningBraceShouldBeIndented { } } if (!class_exists('ClassOpeningBraceTooMuchIndentation')) { final class ClassOpeningBraceTooMuchIndentation { } } PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/Classes/ClassDeclarationUnitTest.1.inc.fixed0000644000076500000240000000407313614652361031123 0ustar gsherwoodstaffsetLogger(new class {}); var_dump(new class(10) extends SomeClass implements SomeInterface { private $num; public function __construct($num) { $this->num = $num; } use SomeTrait; }); class IncorrectClassDeclarationWithCommentAtEnd extends correctClassDeclaration /* Comment */ { } class CorrectClassDeclarationWithCommentAtEnd extends correctClassDeclaration /* Comment */ { } // Don't move phpcs:ignore comments. class PHPCSIgnoreAnnotationAfterOpeningBrace { // phpcs:ignore Standard.Cat.Sniff -- for reasons. } // Moving any of the other trailing phpcs: comments is ok. class PHPCSAnnotationAfterOpeningBrace { // phpcs:disable Standard.Cat.Sniff -- for reasons. } if (!class_exists('ClassOpeningBraceShouldBeIndented')) { abstract class ClassOpeningBraceShouldBeIndented { } } if (!class_exists('ClassOpeningBraceTooMuchIndentation')) { final class ClassOpeningBraceTooMuchIndentation { } } PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/Classes/ClassDeclarationUnitTest.2.inc0000644000076500000240000000033213614652361030020 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Tests\Classes; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ClassDeclarationUnitTest extends AbstractSniffUnitTest { /** * Get a list of CLI values to set before the file is tested. * * @param string $testFile The name of the file being tested. * @param \PHP_CodeSniffer\Config $config The config data for the test run. * * @return void */ public function setCliValues($testFile, $config) { if ($testFile === 'ClassDeclarationUnitTest.1.inc') { return; } $config->tabWidth = 4; }//end setCliValues() /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='') { switch ($testFile) { case 'ClassDeclarationUnitTest.1.inc': return [ 21 => 1, 22 => 1, 23 => 1, 27 => 1, 33 => 1, 38 => 1, 49 => 1, 84 => 1, 94 => 1, 99 => 1, 104 => 1, 110 => 1, ]; default: return []; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getWarningList($testFile='') { if ($testFile === 'ClassDeclarationUnitTest.2.inc') { return [11 => 1]; } return[]; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/Commenting/ClassCommentUnitTest.inc0000644000076500000240000000362213614652361027545 0ustar gsherwoodstaff * @copyright 2006-2014 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence * @version Release: 1.0 * @link http://pear.php.net/package/PHP_CodeSniffer */ class Extra_Description_Newlines { }//end class /** * Sample class comment * @category PHP * @package PHP_CodeSniffer * @author Greg Sherwood * @copyright 2006-2014 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence * @version * @link http://pear.php.net/package/PHP_CodeSniffer */ class Missing_Newlines_Before_Tags { }//end class /** * Simple class comment * * @category _wrong_category * @package PHP_CodeSniffer * @package ADDITIONAL PACKAGE TAG * @subpackage SUBPACKAGE TAG * @author Original Author * @author Greg Sherwood gsherwood@squiz.net * @author Mr T * @author * @copyright 1997~1994 The PHP Group * @license http://www.php.net/license/3_0.txt * @version INVALID VERSION CONTENT * @see * @see * @link sdfsdf * @see Net_Sample::Net_Sample() * @see Net_Other * @deprecated asd * @unknown Unknown tag * @since Class available since Release 1.2.0 */ class Checking_Tags { class Sub_Class { }//end class }//end class /** * * */ class Empty_Class_Doc { }//end class /** * * */ interface Empty_Interface_Doc { }//end interface /** * * */ trait Empty_Trait_Doc { }//end trait PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/Commenting/ClassCommentUnitTest.php0000644000076500000240000000314313614652361027561 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Tests\Commenting; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ClassCommentUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 4 => 1, 15 => 1, 51 => 1, 63 => 1, 65 => 2, 66 => 1, 68 => 1, 70 => 1, 71 => 1, 72 => 1, 74 => 2, 75 => 1, 76 => 1, 77 => 1, 85 => 1, 96 => 5, 106 => 5, 116 => 5, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return [ 71 => 1, 73 => 1, ]; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/Commenting/FileCommentUnitTest.inc0000644000076500000240000000264413614652361027362 0ustar gsherwoodstaff * @author Greg Sherwood gsherwood@squiz.net * @author Mr T * @author * @copyright 1997~1994 The PHP Group * @copyright 1997~1994 The PHP Group * @license http://www.php.net/license/3_0.txt * @see * @see * @version INVALID VERSION CONTENT * @see Net_Sample::Net_Sample() * @see Net_Other * @deprecated asd * @since Class available since Release 1.2.0 * @summary An unknown summary tag * @package '' * @subpackage !! * @author Code AUthor */ require_once '/some/path.php'; ?> PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/Commenting/FileCommentUnitTest.php0000644000076500000240000000307213614652361027374 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Tests\Commenting; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class FileCommentUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 21 => 1, 23 => 2, 24 => 1, 26 => 1, 28 => 1, 29 => 1, 30 => 1, 31 => 1, 32 => 2, 33 => 1, 34 => 1, 35 => 1, 40 => 2, 41 => 2, 43 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return [ 29 => 1, 30 => 1, 34 => 1, 43 => 1, ]; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/Commenting/FunctionCommentUnitTest.inc0000644000076500000240000001425513614652361030271 0ustar gsherwoodstaff line numbers for each token. * * @param array $tokens The array of tokens to process. * @param object $tokenizer The tokenizer being used to process this file. * @param string $eolChar The EOL character to use for splitting strings. * * @return void */ function foo(&$tokens, $tokenizer, $eolChar) { }//end foo() /** * Gettext. * */ function _() { return $foo; } class Baz { /** * The PHP5 constructor * * No return tag */ public function __construct() { } } /** * Complete a step. * * @param string $status Status of step to complete. * @param array $array Array. * @param string $note Optional note. * * @return void */ function completeStep($status, array $array = [Class1::class, 'test'], $note = '') { echo 'foo'; } /** * Variadic function. * * @param string $name1 Comment. * @param string ...$name2 Comment. * * @return void */ function myFunction(string $name1, string ...$name2) { } /** * Variadic function. * * @param string $name1 Comment. * @param string $name2 Comment. * * @return void */ function myFunction(string $name1, string ...$name2) { } /** * Completely invalid format, but should not cause PHP notices. * * @param $bar * Comment here. * @param ... * Additional arguments here. * * @return * Return value * */ function foo($bar) { } /** * Processes the test. * * @param PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where the * token occurred. * @param int $stackPtr The position in the tokens stack * where the listening token type * was found. * * @return void * @see register() */ function process(File $phpcsFile, $stackPtr) { }//end process() /** * Processes the test. * * @param int $phpcsFile The PHP_CodeSniffer * file where the * token occurred. * @param int $stackPtr The position in the tokens stack * where the listening token type * was found. * * @return void * @see register() */ function process(File $phpcsFile, $stackPtr) { }//end process() /** * @param (Foo&Bar)|null $a Comment. * @param string $b Comment. * * @return void */ public function setTranslator($a, &$b): void { $this->translator = $translator; } PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/Commenting/FunctionCommentUnitTest.inc.fixed0000644000076500000240000001421013614652361031356 0ustar gsherwoodstaff line numbers for each token. * * @param array $tokens The array of tokens to process. * @param object $tokenizer The tokenizer being used to process this file. * @param string $eolChar The EOL character to use for splitting strings. * * @return void */ function foo(&$tokens, $tokenizer, $eolChar) { }//end foo() /** * Gettext. * */ function _() { return $foo; } class Baz { /** * The PHP5 constructor * * No return tag */ public function __construct() { } } /** * Complete a step. * * @param string $status Status of step to complete. * @param array $array Array. * @param string $note Optional note. * * @return void */ function completeStep($status, array $array = [Class1::class, 'test'], $note = '') { echo 'foo'; } /** * Variadic function. * * @param string $name1 Comment. * @param string ...$name2 Comment. * * @return void */ function myFunction(string $name1, string ...$name2) { } /** * Variadic function. * * @param string $name1 Comment. * @param string $name2 Comment. * * @return void */ function myFunction(string $name1, string ...$name2) { } /** * Completely invalid format, but should not cause PHP notices. * * @param $bar * Comment here. * @param ... * Additional arguments here. * * @return * Return value * */ function foo($bar) { } /** * Processes the test. * * @param PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where the * token occurred. * @param int $stackPtr The position in the tokens stack * where the listening token type * was found. * * @return void * @see register() */ function process(File $phpcsFile, $stackPtr) { }//end process() /** * Processes the test. * * @param int $phpcsFile The PHP_CodeSniffer * file where the * token occurred. * @param int $stackPtr The position in the tokens stack * where the listening token type * was found. * * @return void * @see register() */ function process(File $phpcsFile, $stackPtr) { }//end process() /** * @param (Foo&Bar)|null $a Comment. * @param string $b Comment. * * @return void */ public function setTranslator($a, &$b): void { $this->translator = $translator; } PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/Commenting/FunctionCommentUnitTest.php0000644000076500000240000000410613614652361030301 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Tests\Commenting; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class FunctionCommentUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 5 => 1, 10 => 1, 12 => 1, 13 => 1, 14 => 1, 15 => 1, 28 => 1, 76 => 1, 87 => 1, 103 => 1, 109 => 1, 112 => 1, 122 => 1, 123 => 2, 124 => 2, 125 => 1, 126 => 1, 137 => 1, 138 => 1, 139 => 1, 152 => 1, 155 => 1, 165 => 1, 172 => 1, 183 => 1, 190 => 2, 206 => 1, 234 => 1, 272 => 1, 313 => 1, 317 => 1, 327 => 1, 329 => 1, 332 => 1, 344 => 1, 343 => 1, 345 => 1, 346 => 1, 360 => 1, 361 => 1, 363 => 1, 364 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/Commenting/InlineCommentUnitTest.inc0000644000076500000240000000060613614652361027715 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Tests\Commenting; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class InlineCommentUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 15 => 1, 24 => 1, 25 => 1, 27 => 1, 28 => 1, 29 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/ControlStructures/ControlSignatureUnitTest.inc0000644000076500000240000000323413614652361032102 0ustar gsherwoodstaff 0); do { echo $i; } while ($i > 0); do { echo $i; } while ($i > 0); do { echo $i; } while ($i > 0); do{ echo $i; }while($i > 0); // while while ($i < 1) { echo $i; } while($i < 1){ echo $i; } while ($i < 1) { echo $i; } // for for ($i = 1; $i < 1; $i++) { echo $i; } for($i = 1; $i < 1; $i++){ echo $i; } for ($i = 1; $i < 1; $i++) { echo $i; } // foreach foreach ($items as $item) { echo $item; } foreach($items as $item){ echo $item; } foreach ($items as $item) { echo $item; } // if if ($i == 0) { $i = 1; } if($i == 0){ $i = 1; } if ($i == 0) { $i = 1; } // else if ($i == 0) { $i = 1; } else { $i = 0; } if ($i == 0) { $i = 1; }else{ $i = 0; } if ($i == 0) { $i = 1; } else { $i = 0; } // else if ($i == 0) { $i = 1; } else { $i = 0; } if ($i == 0) { $i = 1; }else{ $i = 0; } if ($i == 0) { $i = 1; } else { $i = 0; } // else if if ($i == 0) { $i = 1; } else if ($i == 2) { $i = 0; } if ($i == 0) { $i = 1; } elseif ($i == 2) { $i = 0; } if ($i == 0) { $i = 1; }else if($i == 2){ $i = 0; } if ($i == 0) { $i = 1; }elseif($i == 2){ $i = 0; } if ($i == 0) { $i = 1; } else if ($i == 2) { $i = 0; } if ($i == 0) { $i = 1; } elseif ($i == 2) { $i = 0; } if ($i == 0) { // this is ok because comments are allowed $i = 1; } if ($i == 0) {// this is ok because comments are allowed $i = 1; } if ($i == 0) { /* this is ok because comments are allowed*/ $i = 1; } if ($i == 0) { // this is not ok $i = 1; } if ($i == 0) /* this is ok */ { } if ($i == 0) { } else { } ?>PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/ControlStructures/ControlSignatureUnitTest.php0000644000076500000240000000322713614652361032122 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Tests\ControlStructures; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ControlSignatureUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 9 => 1, 14 => 1, 20 => 1, 22 => 1, 32 => 1, 36 => 1, 44 => 1, 48 => 1, 56 => 1, 60 => 1, 68 => 1, 72 => 1, 84 => 1, 88 => 2, 100 => 1, 104 => 2, 122 => 2, 128 => 1, 132 => 3, 133 => 2, 147 => 1, 157 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/ControlStructures/MultiLineConditionUnitTest.inc0000644000076500000240000000751313614652361032355 0ustar gsherwoodstaff

some text

errorCode() == 401 || // comment $IPP->errorCode() == 3200) /* long comment here */ { return false; } if ($IPP->errorCode() == 401 || // comment $IPP->errorCode() == 3200) // long comment here { return false; } if ($IPP->errorCode() == 401 // Comment explaining the next condition here. || $IPP->errorCode() == 3200 ) { return false; } function bar() { if ($a && $b ) { return false; } } if ($a && foo( 'a', 'b' )) { return false; } ?> errorCode() == 401 || // phpcs:ignore Standard.Category.Sniff -- for reasons. $IPP->errorCode() == 3200) /* phpcs:ignore Standard.Category.Sniff -- for reasons. */ { return false; } if ($IPP->errorCode() == 401 || // phpcs:disable Standard.Category.Sniff -- for reasons. $IPP->errorCode() == 3200) // phpcs:enable { return false; } if ($IPP->errorCode() == 401 // phpcs:ignore Standard.Category.Sniff -- for reasons. || $IPP->errorCode() == 3200 ) { return false; } if ($IPP->errorCode() == 401 || /* * phpcs:disable Standard.Category.Sniff -- for reasons. */ $IPP->errorCode() == 3200 ) { return false; } if ($IPP->errorCode() == 401 || $IPP->errorCode() == 3200 // phpcs:ignore Standard.Category.Sniff -- for reasons. ) { return false; } if ($IPP->errorCode() == 401 || $IPP->errorCode() === 'someverylongexpectedoutput' ) { return false; } if ($IPP->errorCode() == 401 || $IPP->errorCode() // A comment. === 'someverylongexpectedoutput' ) { return false; } if ($IPP->errorCode() == 401 || $IPP->errorCode() // phpcs:ignore Standard.Category.Sniff -- for reasons. === 'someverylongexpectedoutput' ) { return false; } ././@LongLink0000000000000000000000000000014500000000000007755 Lustar PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/ControlStructures/MultiLineConditionUnitTest.inc.fixedPHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/ControlStructures/MultiLineConditionUnitTest.inc.fixe0000644000076500000240000000750213614652361033305 0ustar gsherwoodstaff

some text

errorCode() == 401 // comment || $IPP->errorCode() == 3200 /* long comment here */ ) { return false; } if ($IPP->errorCode() == 401 // comment || $IPP->errorCode() == 3200 // long comment here ) { return false; } if ($IPP->errorCode() == 401 // Comment explaining the next condition here. || $IPP->errorCode() == 3200 ) { return false; } function bar() { if ($a && $b ) { return false; } } if ($a && foo( 'a', 'b' ) ) { return false; } ?> errorCode() == 401 // phpcs:ignore Standard.Category.Sniff -- for reasons. || $IPP->errorCode() == 3200 /* phpcs:ignore Standard.Category.Sniff -- for reasons. */ ) { return false; } if ($IPP->errorCode() == 401 // phpcs:disable Standard.Category.Sniff -- for reasons. || $IPP->errorCode() == 3200 // phpcs:enable ) { return false; } if ($IPP->errorCode() == 401 // phpcs:ignore Standard.Category.Sniff -- for reasons. || $IPP->errorCode() == 3200 ) { return false; } if ($IPP->errorCode() == 401 /* * phpcs:disable Standard.Category.Sniff -- for reasons. */ || $IPP->errorCode() == 3200 ) { return false; } if ($IPP->errorCode() == 401 || $IPP->errorCode() == 3200 // phpcs:ignore Standard.Category.Sniff -- for reasons. ) { return false; } if ($IPP->errorCode() == 401 || $IPP->errorCode() === 'someverylongexpectedoutput' ) { return false; } if ($IPP->errorCode() == 401 || $IPP->errorCode() // A comment. === 'someverylongexpectedoutput' ) { return false; } if ($IPP->errorCode() == 401 || $IPP->errorCode() // phpcs:ignore Standard.Category.Sniff -- for reasons. === 'someverylongexpectedoutput' ) { return false; } PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/ControlStructures/MultiLineConditionUnitTest.js0000644000076500000240000000643013614652361032215 0ustar gsherwoodstaffif (blah(param)) { } if ((condition1 || condition2) && condition3 && condition4 && condition5 ) { } if ((condition1 || condition2) && condition3 && condition4 && condition5) { } if ((condition1 || condition2) && condition3 ) { } if ( (condition1 || condition2) && condition3 ) { } if ((condition1 || condition2) ) { } if ((condition1 || condition2) && condition3 && condition4 ) { } if ((condition1 || condition2) && condition3 && condition4 && condition5 ) { } if (($condition1 || $condition2) ) { } if ((condition1 || condition2) ) { } if ( ( condition1 || condition2 ) && condition3 ) { } if ( condition1 || condition2 || condition3 ) { } if (condition1 || condition2 || condition3 ) { } else if (condition1 || condition2 || condition3 ) { } if (condition1 || condition2 || condition3 ) { } else if ( condition1 || condition2 && condition3 ) { } if (condition1 || condition2 || condition3) { } if (condition1 || condition2 || condition3 ){ } if (condition1) console.info('bar'); if (condition1 || condition2 || condition3) console.info('bar'); if (condition1 || condition2 || condition3 ) console.info('bar'); if (!a(post) && (!a(context.header) ^ a(context.header, 'Content-Type')) ) { // ... } if (foo) { console.info('bar'); } // Should be no errors even though lines are // not exactly aligned together. Multi-line function // call takes precedence. if (array_key_exists(key, value) && foo.bar.baz( key, value2 ) ) { } if (true) { foo = true; }; if (foo == 401 || // comment bar == 3200) /* long comment here */ { return false; } if (foo == 401 || // comment bar == 3200) // long comment here { return false; } if (IPP.errorCode() == 401 // Comment explaining the next condition here. || IPP.errorCode() == 3200 ) { return false; } function bar() { if (a && b ) { return false; } } if (a && foo( 'a', 'b' )) { return false; } if (foo == 401 || // phpcs:ignore Standard.Category.Sniff -- for reasons. bar == 3200) /* phpcs:ignore Standard.Category.Sniff -- for reasons. */ { return false; } if (foo == 401 || // phpcs:disable Standard.Category.Sniff -- for reasons. bar == 3200) // phpcs:enable { return false; } if (IPP.errorCode() == 401 // phpcs:ignore Standard.Category.Sniff -- for reasons. || IPP.errorCode() == 3200 ) { return false; } if (foo == 401 || /* * phpcs:disable Standard.Category.Sniff -- for reasons. */ bar == 3200 ) { return false; } if (IPP.errorCode() == 401 || IPP.errorCode() == 3200 // phpcs:ignore Standard.Category.Sniff -- for reasons. ) { return false; } if (foo == 401 || bar == 'someverylongexpectedoutput' ) { return false; } if (IPP.errorCode() == 401 || bar // A comment. == 'someverylongexpectedoutput' ) { return false; } if (foo == 401 || IPP.errorCode() // phpcs:ignore Standard.Category.Sniff -- for reasons. == 'someverylongexpectedoutput' ) { return false; } ././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/ControlStructures/MultiLineConditionUnitTest.js.fixedPHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/ControlStructures/MultiLineConditionUnitTest.js.fixed0000644000076500000240000000641613614652361033317 0ustar gsherwoodstaffif (blah(param)) { } if ((condition1 || condition2) && condition3 && condition4 && condition5 ) { } if ((condition1 || condition2) && condition3 && condition4 && condition5) { } if ((condition1 || condition2) && condition3 ) { } if ((condition1 || condition2) && condition3 ) { } if ((condition1 || condition2) ) { } if ((condition1 || condition2) && condition3 && condition4 ) { } if ((condition1 || condition2) && condition3 && condition4 && condition5 ) { } if (($condition1 || $condition2) ) { } if ((condition1 || condition2) ) { } if ((condition1 || condition2) && condition3 ) { } if (condition1 || condition2 || condition3 ) { } if (condition1 || condition2 || condition3 ) { } else if (condition1 || condition2 || condition3 ) { } if (condition1 || condition2 || condition3 ) { } else if (condition1 || condition2 && condition3 ) { } if (condition1 || condition2 || condition3 ) { } if (condition1 || condition2 || condition3 ) { } if (condition1) console.info('bar'); if (condition1 || condition2 || condition3 ) console.info('bar'); if (condition1 || condition2 || condition3 ) console.info('bar'); if (!a(post) && (!a(context.header) ^ a(context.header, 'Content-Type')) ) { // ... } if (foo) { console.info('bar'); } // Should be no errors even though lines are // not exactly aligned together. Multi-line function // call takes precedence. if (array_key_exists(key, value) && foo.bar.baz( key, value2 ) ) { } if (true) { foo = true; }; if (foo == 401 // comment || bar == 3200 /* long comment here */ ) { return false; } if (foo == 401 // comment || bar == 3200 // long comment here ) { return false; } if (IPP.errorCode() == 401 // Comment explaining the next condition here. || IPP.errorCode() == 3200 ) { return false; } function bar() { if (a && b ) { return false; } } if (a && foo( 'a', 'b' ) ) { return false; } if (foo == 401 // phpcs:ignore Standard.Category.Sniff -- for reasons. || bar == 3200 /* phpcs:ignore Standard.Category.Sniff -- for reasons. */ ) { return false; } if (foo == 401 // phpcs:disable Standard.Category.Sniff -- for reasons. || bar == 3200 // phpcs:enable ) { return false; } if (IPP.errorCode() == 401 // phpcs:ignore Standard.Category.Sniff -- for reasons. || IPP.errorCode() == 3200 ) { return false; } if (foo == 401 /* * phpcs:disable Standard.Category.Sniff -- for reasons. */ || bar == 3200 ) { return false; } if (IPP.errorCode() == 401 || IPP.errorCode() == 3200 // phpcs:ignore Standard.Category.Sniff -- for reasons. ) { return false; } if (foo == 401 || bar == 'someverylongexpectedoutput' ) { return false; } if (IPP.errorCode() == 401 || bar // A comment. == 'someverylongexpectedoutput' ) { return false; } if (foo == 401 || IPP.errorCode() // phpcs:ignore Standard.Category.Sniff -- for reasons. == 'someverylongexpectedoutput' ) { return false; } PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/ControlStructures/MultiLineConditionUnitTest.php0000644000076500000240000000423113614652361032365 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Tests\ControlStructures; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class MultiLineConditionUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='MultiLineConditionUnitTest.inc') { $errors = [ 21 => 1, 22 => 1, 35 => 1, 40 => 1, 41 => 1, 42 => 1, 43 => 1, 49 => 1, 54 => 1, 57 => 1, 58 => 1, 59 => 1, 61 => 1, 67 => 1, 87 => 1, 88 => 1, 89 => 1, 90 => 1, 96 => 2, 101 => 1, 109 => 2, 125 => 1, 145 => 2, 153 => 2, 168 => 1, 177 => 1, 194 => 2, 202 => 2, 215 => 1, 218 => 2, 232 => 2, 239 => 1, 240 => 2, 248 => 2, ]; if ($testFile === 'MultiLineConditionUnitTest.inc') { $errors[183] = 1; } return $errors; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/Files/IncludingFileUnitTest.inc0000644000076500000240000000317713614652361026640 0ustar gsherwoodstaff 
Some content goes here.


    Some content goes here.
    
    
Some content goes here.


    Some content goes here.
* @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Tests\Files; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class IncludingFileUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 4 => 1, 5 => 1, 11 => 1, 12 => 1, 16 => 1, 17 => 1, 33 => 1, 34 => 1, 47 => 1, 48 => 1, 64 => 1, 65 => 1, 73 => 1, 74 => 1, 85 => 1, 86 => 1, 98 => 1, 99 => 2, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/Formatting/MultiLineAssignmentUnitTest.inc0000644000076500000240000000135713614652361031125 0ustar gsherwoodstaffadditionalHeaderData[$this->strApplicationName] = $this->xajax->getJavascript(t3lib_extMgm::siteRelPath('nr_xajax')); $GLOBALS['TSFE']->additionalHeaderData[$this->strApplicationName] = $this->xajax->getJavascript(t3lib_extMgm::siteRelPath('nr_xajax')); $GLOBALS['TSFE']->additionalHeaderData[$this->strApplicationName] = $this->xajax->getJavascript(t3lib_extMgm::siteRelPath('nr_xajax')); $GLOBALS['TSFE']->additionalHeaderData[$this->strApplicationName] = $this->xajax->getJavascript(t3lib_extMgm::siteRelPath('nr_xajax')); $GLOBALS['TSFE']->additionalHeaderData[$this->strApplicationName] = 'boo'; $var='string'; function getInstalledStandards( $includeGeneric=false, $standardsDir='' ) { } ?> PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/Formatting/MultiLineAssignmentUnitTest.php0000644000076500000240000000235613614652361031143 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Tests\Formatting; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class MultiLineAssignmentUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 3 => 1, 6 => 1, 8 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/Functions/FunctionCallSignatureUnitTest.inc0000644000076500000240000002220713614652361031270 0ustar gsherwoodstaffgetFoo() ->doBar( $this->getX() // no comma here ->doY() // this is still the first method argument ->doZ() // this is still the first method argument ); } $var = myFunction( $foo, $bar ); // phpcs:set PEAR.Functions.FunctionCallSignature allowMultipleArguments false fputs( STDOUT, "Examples: $ {$app} , --all $ {$app} --all", $something ); $array = array(); array_map( function($x) { return trim($x, $y); }, $foo, $array ); $bar = new stdClass( 4, /* thanks */ 5, /* PSR-2 */ 6 ); function doSomething() { return $this->getFoo() ->doBar( $this->getX() // no comma here ->doY() // this is still the first method argument ->doZ() // this is still the first method argument ); } doError( 404, // status code 'Not Found', // error name 'Check your id' // fix ); // phpcs:set PEAR.Functions.FunctionCallSignature allowMultipleArguments true // Don't report errors for closing braces. Leave that to other sniffs. foo( [ 'this', 'is', 'an', 'array' ], [ 'this', 'is', 'an', 'array' ], array( 'this', 'is', 'an', 'array' ), array( 'this', 'is', 'an', 'array' ), function($x) { echo 'wee'; return trim($x); } ); function foo() { myFunction( 'string'. // comment // comment 'string'. /* comment * comment */ 'string' ); } // phpcs:set PEAR.Functions.FunctionCallSignature requiredSpacesAfterOpen 1 // phpcs:set PEAR.Functions.FunctionCallSignature requiredSpacesBeforeClose 1 test($arg, $arg2); test( $arg, $arg2 ); test( $arg, $arg2 ); test(); test( ); test( ); // phpcs:set PEAR.Functions.FunctionCallSignature requiredSpacesAfterOpen 0 // phpcs:set PEAR.Functions.FunctionCallSignature requiredSpacesBeforeClose 0 ?>
    • log(// ... 'error', sprintf( 'Message: %s', isset($e->getData()['object']['evidence_details']) ? $e->getData()['object']['evidence_details']['due_by'] : '' ), array($e->getData()['object']) ); ?>
    $class ] ); ?>
    function ($x) { return true; }, 'baz' => false ) ); $qux = array_filter( $quux, function ($x) { return $x; } ); array_filter( [1, 2], function ($i) : bool { return $i === 0; } ); foo(array( 'callback' => function () { $foo = 'foo'; return; }, )); foo( $a, /* $c, $d, */ $e ); test( 1,2,3,4 ); class Test { public function getInstance() { return new static( 'arg', 'foo' ); } public function getSelf() { return new self( 'a','b', 'c' ); } } $x = $var('y', 'x'); $obj->{$x}(1, 2); return (function ($a, $b) { return function ($c, $d) use ($a, $b) { echo $a, $b, $c, $d; }; })( 'a','b' )('c', 'd'); class Foo { public function bar($a, $b) { if (!$a || !$b) { return; } (new stdClass())->a = $a; } } return (function ($a, $b) { return function ($c, $d) use ($a, $b) { echo $a, $b, $c, $d; }; })('a','b')('c','d'); function foo() { Bar( function () { } ); } $deprecated_functions = [ 'the_category_ID' => function_call( // 7 spaces, not 8. This is the problem line. $a, $b ), ]; $deprecated_functions = [ 'the_category_ID' => function_call( // 9 spaces, not 8. This is the problem line. $a, $b ), ]; // phpcs:set PEAR.Functions.FunctionCallSignature allowMultipleArguments false printf( '', $obj->getName(), // Trailing comment. $obj->getID(), // phpcs:ignore Standard.Category.SniffName -- for reasons. $option ); // Handling of PHP 7.3 trailing comma's. functionCall($args, $foo,); functionCall( $args, $foo, ); functionCall( $args, $foo, ); // phpcs:set PEAR.Functions.FunctionCallSignature allowMultipleArguments true $this->foo( ['a','b'], true ); $this->foo( // Comment ['a','b'], true ); function m() { $t = ' ' . (empty(true) ? ' ' . f( '1', '2', ) . ' ' : ''); } class C { public function m() { $a = []; $t = "SELECT * FROM t WHERE f IN(" . implode( ",", $a ) . ")"; } } $notices = array( 'index' => sprintf( translation_function('a text string with %s placeholder'), 'replacement' ), ); $componentType = $this->componentTypeRepository->findByType($this->identifier) ?: $this->componentTypeFactory->createForType( $this->identifier, $this->className, true, $this->isPrototypal ); return [ 'export-path' => 'exports/database/' . env( 'APP_CUSTOMER', 'not-configured' ) . '/' . env( 'APP_IDENTIFIER', 'not-configured' ), ]; $methods .= str_replace( array_keys($replacements), array_values($replacements), $methodTemplate ) . PHP_EOL . PHP_EOL . str_repeat(' ', 4); $rangeValues['min'] = $this->adjustLowerThreshold( $this->normalizeRatingForFilter($rangeValues['min']) ); $salesOrderThresholdTransfer->fromArray($salesOrderThresholdEntity->toArray(), true) ->setSalesOrderThresholdValue( $this->mapSalesOrderThresholdValueTransfer($salesOrderThresholdTransfer, $salesOrderThresholdEntity) )->setCurrency( (new CurrencyTransfer())->fromArray($salesOrderThresholdEntity->getCurrency()->toArray(), true) )->setStore( (new StoreTransfer())->fromArray($salesOrderThresholdEntity->getStore()->toArray(), true) ); return trim(preg_replace_callback( // sprintf replaces IGNORED_CHARS multiple times: for %s as well as %1$s (argument numbering) // /[%s]*([^%1$s]+)/ results in /[IGNORED_CHARS]*([^IGNORED_CHARS]+)/ sprintf('/[%s]*([^%1$s]+)/', self::IGNORED_CHARS), function (array $term) use ($mode): string { // query pieces have to bigger than one char, otherwise they are too expensive for the search if (mb_strlen($term[1], 'UTF-8') > 1) { // in boolean search mode '' (empty) means OR, '-' means NOT return sprintf('%s%s ', $mode === 'AND' ? '+' : '', self::extractUmlauts($term[1])); } return ''; }, $search )); PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/Functions/FunctionCallSignatureUnitTest.inc.fixed0000644000076500000240000002213013614652361032361 0ustar gsherwoodstaffgetFoo() ->doBar( $this->getX() // no comma here ->doY() // this is still the first method argument ->doZ() // this is still the first method argument ); } $var = myFunction( $foo, $bar ); // phpcs:set PEAR.Functions.FunctionCallSignature allowMultipleArguments false fputs( STDOUT, "Examples: $ {$app} , --all $ {$app} --all", $something ); $array = array(); array_map( function($x) { return trim($x, $y); }, $foo, $array ); $bar = new stdClass( 4, /* thanks */ 5, /* PSR-2 */ 6 ); function doSomething() { return $this->getFoo() ->doBar( $this->getX() // no comma here ->doY() // this is still the first method argument ->doZ() // this is still the first method argument ); } doError( 404, // status code 'Not Found', // error name 'Check your id' // fix ); // phpcs:set PEAR.Functions.FunctionCallSignature allowMultipleArguments true // Don't report errors for closing braces. Leave that to other sniffs. foo( [ 'this', 'is', 'an', 'array' ], [ 'this', 'is', 'an', 'array' ], array( 'this', 'is', 'an', 'array' ), array( 'this', 'is', 'an', 'array' ), function($x) { echo 'wee'; return trim($x); } ); function foo() { myFunction( 'string'. // comment // comment 'string'. /* comment * comment */ 'string' ); } // phpcs:set PEAR.Functions.FunctionCallSignature requiredSpacesAfterOpen 1 // phpcs:set PEAR.Functions.FunctionCallSignature requiredSpacesBeforeClose 1 test( $arg, $arg2 ); test( $arg, $arg2 ); test( $arg, $arg2 ); test(); test(); test(); // phpcs:set PEAR.Functions.FunctionCallSignature requiredSpacesAfterOpen 0 // phpcs:set PEAR.Functions.FunctionCallSignature requiredSpacesBeforeClose 0 ?>
    • log(// ... 'error', sprintf( 'Message: %s', isset($e->getData()['object']['evidence_details']) ? $e->getData()['object']['evidence_details']['due_by'] : '' ), array($e->getData()['object']) ); ?>
    $class ] ); ?>
    function ($x) { return true; }, 'baz' => false ) ); $qux = array_filter( $quux, function ($x) { return $x; } ); array_filter( [1, 2], function ($i) : bool { return $i === 0; } ); foo( array( 'callback' => function () { $foo = 'foo'; return; }, ) ); foo( $a, /* $c, $d, */ $e ); test( 1,2,3,4 ); class Test { public function getInstance() { return new static( 'arg', 'foo' ); } public function getSelf() { return new self( 'a','b', 'c' ); } } $x = $var( 'y', 'x' ); $obj->{$x}( 1, 2 ); return (function ($a, $b) { return function ($c, $d) use ($a, $b) { echo $a, $b, $c, $d; }; })( 'a','b' )( 'c', 'd' ); class Foo { public function bar($a, $b) { if (!$a || !$b) { return; } (new stdClass())->a = $a; } } return (function ($a, $b) { return function ($c, $d) use ($a, $b) { echo $a, $b, $c, $d; }; })('a','b')('c','d'); function foo() { Bar( function () { } ); } $deprecated_functions = [ 'the_category_ID' => function_call( // 7 spaces, not 8. This is the problem line. $a, $b ), ]; $deprecated_functions = [ 'the_category_ID' => function_call( // 9 spaces, not 8. This is the problem line. $a, $b ), ]; // phpcs:set PEAR.Functions.FunctionCallSignature allowMultipleArguments false printf( '', $obj->getName(), // Trailing comment. $obj->getID(), // phpcs:ignore Standard.Category.SniffName -- for reasons. $option ); // Handling of PHP 7.3 trailing comma's. functionCall($args, $foo,); functionCall( $args, $foo, ); functionCall( $args, $foo, ); // phpcs:set PEAR.Functions.FunctionCallSignature allowMultipleArguments true $this->foo( ['a','b'], true ); $this->foo( // Comment ['a','b'], true ); function m() { $t = ' ' . (empty(true) ? ' ' . f( '1', '2', ) . ' ' : ''); } class C { public function m() { $a = []; $t = "SELECT * FROM t WHERE f IN(" . implode( ",", $a ) . ")"; } } $notices = array( 'index' => sprintf( translation_function('a text string with %s placeholder'), 'replacement' ), ); $componentType = $this->componentTypeRepository->findByType($this->identifier) ?: $this->componentTypeFactory->createForType( $this->identifier, $this->className, true, $this->isPrototypal ); return [ 'export-path' => 'exports/database/' . env( 'APP_CUSTOMER', 'not-configured' ) . '/' . env( 'APP_IDENTIFIER', 'not-configured' ), ]; $methods .= str_replace( array_keys($replacements), array_values($replacements), $methodTemplate ) . PHP_EOL . PHP_EOL . str_repeat(' ', 4); $rangeValues['min'] = $this->adjustLowerThreshold( $this->normalizeRatingForFilter($rangeValues['min']) ); $salesOrderThresholdTransfer->fromArray($salesOrderThresholdEntity->toArray(), true) ->setSalesOrderThresholdValue( $this->mapSalesOrderThresholdValueTransfer($salesOrderThresholdTransfer, $salesOrderThresholdEntity) )->setCurrency( (new CurrencyTransfer())->fromArray($salesOrderThresholdEntity->getCurrency()->toArray(), true) )->setStore( (new StoreTransfer())->fromArray($salesOrderThresholdEntity->getStore()->toArray(), true) ); return trim( preg_replace_callback( // sprintf replaces IGNORED_CHARS multiple times: for %s as well as %1$s (argument numbering) // /[%s]*([^%1$s]+)/ results in /[IGNORED_CHARS]*([^IGNORED_CHARS]+)/ sprintf('/[%s]*([^%1$s]+)/', self::IGNORED_CHARS), function (array $term) use ($mode): string { // query pieces have to bigger than one char, otherwise they are too expensive for the search if (mb_strlen($term[1], 'UTF-8') > 1) { // in boolean search mode '' (empty) means OR, '-' means NOT return sprintf('%s%s ', $mode === 'AND' ? '+' : '', self::extractUmlauts($term[1])); } return ''; }, $search ) ); PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/Functions/FunctionCallSignatureUnitTest.js0000644000076500000240000000330013614652361031124 0ustar gsherwoodstafftest( ); test(); test(arg, arg2); test (); test( ); test() ; test( arg); test( arg ); test ( arg ); if (foo(arg) === true) { } var something = get(arg1, arg2); var something = get(arg1, arg2) ; var something = get(arg1, arg2) ; make_foo(string/*the string*/, true/*test*/); make_foo(string/*the string*/, true/*test*/ ); make_foo(string /*the string*/, true /*test*/); make_foo(/*the string*/string, /*test*/true); make_foo( /*the string*/string, /*test*/true); // phpcs:set PEAR.Functions.FunctionCallSignature requiredSpacesAfterOpen 1 // phpcs:set PEAR.Functions.FunctionCallSignature requiredSpacesBeforeClose 1 test(arg, arg2); test( arg, arg2 ); test( arg, arg2 ); // phpcs:set PEAR.Functions.FunctionCallSignature requiredSpacesAfterOpen 0 // phpcs:set PEAR.Functions.FunctionCallSignature requiredSpacesBeforeClose 0 this.init = function(data) { a.b('').a(function(itemid, target) { b( itemid, target, { reviewData: _reviewData, pageid: itemid }, '', function() { var _showAspectItems = function(itemid) { a.a(a.c(''), ''); a.b(a.c('-' + itemid), ''); }; a.foo(function(itemid, target) { _foo(itemid); }); } ); }); }; a.prototype = { a: function() { this.addItem( { /** * @return void */ a: function() { }, /** * @return void */ a: function() { }, } ); } }; PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/Functions/FunctionCallSignatureUnitTest.js.fixed0000644000076500000240000000337413614652361032235 0ustar gsherwoodstafftest( ); test(); test(arg, arg2); test(); test(); test(); test(arg); test(arg); test(arg); if (foo(arg) === true) { } var something = get(arg1, arg2); var something = get(arg1, arg2); var something = get(arg1, arg2); make_foo(string/*the string*/, true/*test*/); make_foo(string/*the string*/, true/*test*/); make_foo(string /*the string*/, true /*test*/); make_foo(/*the string*/string, /*test*/true); make_foo(/*the string*/string, /*test*/true); // phpcs:set PEAR.Functions.FunctionCallSignature requiredSpacesAfterOpen 1 // phpcs:set PEAR.Functions.FunctionCallSignature requiredSpacesBeforeClose 1 test( arg, arg2 ); test( arg, arg2 ); test( arg, arg2 ); // phpcs:set PEAR.Functions.FunctionCallSignature requiredSpacesAfterOpen 0 // phpcs:set PEAR.Functions.FunctionCallSignature requiredSpacesBeforeClose 0 this.init = function(data) { a.b('').a( function(itemid, target) { b( itemid, target, { reviewData: _reviewData, pageid: itemid }, '', function() { var _showAspectItems = function(itemid) { a.a(a.c(''), ''); a.b(a.c('-' + itemid), ''); }; a.foo( function(itemid, target) { _foo(itemid); } ); } ); } ); }; a.prototype = { a: function() { this.addItem( { /** * @return void */ a: function() { }, /** * @return void */ a: function() { }, } ); } }; PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/Functions/FunctionCallSignatureUnitTest.php0000644000076500000240000000670013614652361031306 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Tests\Functions; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class FunctionCallSignatureUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='FunctionCallSignatureUnitTest.inc') { if ($testFile === 'FunctionCallSignatureUnitTest.js') { return [ 5 => 1, 6 => 2, 7 => 1, 8 => 1, 9 => 2, 10 => 3, 17 => 1, 18 => 1, 21 => 1, 24 => 1, 28 => 2, 30 => 2, 35 => 1, 49 => 1, 51 => 1, 54 => 1, 70 => 1, 71 => 1, ]; }//end if return [ 5 => 1, 6 => 2, 7 => 1, 8 => 1, 9 => 2, 10 => 3, 17 => 1, 18 => 1, 31 => 1, 34 => 1, 43 => 2, 57 => 1, 59 => 1, 63 => 1, 64 => 1, 82 => 1, 93 => 1, 100 => 1, 106 => 2, 119 => 1, 120 => 1, 129 => 1, 137 => 1, 142 => 2, 171 => 1, 180 => 1, 181 => 1, 194 => 1, 213 => 2, 215 => 2, 217 => 2, 218 => 2, 277 => 1, 278 => 1, 303 => 1, 308 => 1, 321 => 1, 322 => 1, 329 => 1, 330 => 1, 337 => 1, 342 => 1, 343 => 1, 345 => 1, 346 => 2, 353 => 1, 354 => 1, 355 => 2, 377 => 1, 378 => 1, 379 => 1, 380 => 1, 385 => 1, 386 => 1, 387 => 1, 388 => 1, 393 => 1, 394 => 1, 395 => 1, 396 => 1, 411 => 1, 422 => 1, 424 => 1, 429 => 1, 432 => 1, 440 => 1, 441 => 1, 442 => 1, 464 => 1, 510 => 1, 513 => 1, 514 => 1, 523 => 1, 524 => 3, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/Functions/FunctionDeclarationUnitTest.inc0000644000076500000240000001071013614652361030754 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Tests\Functions; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class FunctionDeclarationUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='FunctionDeclarationUnitTest.inc') { if ($testFile === 'FunctionDeclarationUnitTest.inc') { $errors = [ 3 => 1, 4 => 1, 5 => 1, 9 => 1, 10 => 1, 11 => 1, 14 => 1, 17 => 1, 44 => 1, 52 => 1, 61 => 2, 98 => 1, 110 => 2, 120 => 3, 121 => 1, 140 => 1, 145 => 1, 161 => 2, 162 => 2, 164 => 2, 167 => 2, 171 => 1, 173 => 1, 201 => 1, 206 => 1, 208 => 1, 216 => 1, 223 => 1, 230 => 1, 237 => 1, 243 => 1, 247 => 1, 251 => 2, 253 => 2, 257 => 2, 259 => 1, 263 => 1, 265 => 1, 269 => 1, 273 => 1, 277 => 1, 278 => 1, 283 => 1, 287 => 2, 289 => 2, 293 => 2, 295 => 1, 299 => 1, 301 => 1, 305 => 1, 309 => 1, 313 => 1, 314 => 1, ]; } else { $errors = [ 3 => 1, 4 => 1, 5 => 1, 9 => 1, 10 => 1, 11 => 1, 14 => 1, 17 => 1, 41 => 1, 48 => 1, ]; }//end if return $errors; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/Functions/ValidDefaultValueUnitTest.inc0000644000076500000240000000354713614652361030374 0ustar gsherwoodstaff $a[] = $b; // Intentional syntax error. Must be last thing in the file. function PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/Functions/ValidDefaultValueUnitTest.php0000644000076500000240000000256313614652361030407 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Tests\Functions; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ValidDefaultValueUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 29 => 1, 34 => 1, 39 => 1, 71 => 1, 76 => 1, 81 => 1, 91 => 1, 99 => 1, 101 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/NamingConventions/ValidClassNameUnitTest.inc0000644000076500000240000000136413614652361031343 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Tests\NamingConventions; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ValidClassNameUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 5 => 1, 7 => 2, 9 => 1, 19 => 1, 24 => 1, 26 => 2, 28 => 1, 38 => 1, 40 => 2, 42 => 2, 44 => 1, 46 => 1, 50 => 1, 52 => 2, 54 => 1, 64 => 1, 66 => 2, 68 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/NamingConventions/ValidFunctionNameUnitTest.inc0000644000076500000240000001371313614652361032064 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Tests\NamingConventions; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ValidFunctionNameUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 11 => 1, 12 => 1, 13 => 1, 14 => 1, 15 => 1, 16 => 1, 17 => 2, 18 => 2, 19 => 2, 20 => 2, 24 => 1, 25 => 1, 26 => 1, 27 => 1, 28 => 1, 29 => 1, 30 => 2, 31 => 2, 32 => 2, 33 => 2, 35 => 1, 36 => 1, 37 => 2, 38 => 2, 39 => 2, 40 => 2, 43 => 1, 44 => 1, 45 => 1, 46 => 1, 50 => 1, 51 => 1, 52 => 1, 53 => 1, 56 => 1, 57 => 1, 58 => 1, 59 => 1, 67 => 1, 68 => 1, 69 => 1, 70 => 1, 71 => 1, 72 => 1, 73 => 2, 74 => 2, 75 => 2, 76 => 2, 80 => 1, 81 => 1, 82 => 1, 83 => 1, 86 => 1, 87 => 1, 88 => 1, 89 => 1, 95 => 1, 96 => 1, 97 => 1, 98 => 1, 99 => 1, 100 => 1, 101 => 2, 102 => 2, 103 => 2, 104 => 2, 123 => 1, 125 => 1, 126 => 2, 129 => 1, 130 => 1, 131 => 1, 132 => 1, 133 => 1, 134 => 1, 135 => 1, 136 => 1, 137 => 1, 138 => 1, 139 => 1, 140 => 3, 141 => 1, 143 => 1, 144 => 1, 145 => 3, 147 => 2, 148 => 1, 149 => 1, 181 => 1, 201 => 1, 203 => 1, 204 => 2, 207 => 2, 212 => 1, 213 => 1, 214 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/NamingConventions/ValidVariableNameUnitTest.inc0000644000076500000240000000322313614652361032017 0ustar gsherwoodstaffdef["POP_{$cc}_A"]}' and POP_{$cc}_B = '{$this->def["POP_{$cc}_B"]}')"; } } class mpgResponse{ var $term_id; var $currentTag; function characterHandler($parser,$data){ switch($this->currentTag) { case "term_id": { $this->term_id=$data; break; } } }//end characterHandler }//end class mpgResponse class foo { const bar = <<setLogger( new class { private $varName = 'hello'; private $_varName = 'hello'; }); PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/NamingConventions/ValidVariableNameUnitTest.php0000644000076500000240000000251013614652361032033 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Tests\NamingConventions; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ValidVariableNameUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 12 => 1, 17 => 1, 22 => 1, 92 => 1, 93 => 1, 94 => 1, 99 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/WhiteSpace/ObjectOperatorIndentUnitTest.inc0000644000076500000240000000335313614652361031176 0ustar gsherwoodstaffsomeFunction("some", "parameter") ->someOtherFunc(23, 42)-> someOtherFunc2($one, $two) ->someOtherFunc3(23, 42) ->andAThirdFunction(); $someObject->someFunction("some", "parameter") ->someOtherFunc(23, 42); $someObject->someFunction("some", "parameter")->someOtherFunc(23, 42); $someObject->someFunction("some", "parameter") ->someOtherFunc(23, 42); func( $bar->foo() ) ->bar(); func( $bar->foo() ) ->bar( $bar->foo() ->bar() ->func() ); $object ->setBar($foo) ->setFoo($bar); if ($bar) { $object ->setBar($foo) ->setFoo($bar); } $response -> CompletedTrackDetails -> TrackDetails -> Events; $response -> CompletedTrackDetails -> TrackDetails -> Events; $response -> CompletedTrackDetails -> TrackDetails -> Events; $var = get_object( $foo->something() ->query() )->two() ->three(); $foo->one( $foo ->two() ); get_object()->one() ->two() ->three(); someclass::one() ->two() ->three(); (new someclass())->one() ->two() ->three(); // phpcs:set PEAR.WhiteSpace.ObjectOperatorIndent multilevel true $someObject ->startSomething() ->someOtherFunc(23, 42) ->endSomething() ->doSomething(23, 42) ->endEverything(); $rootNode ->one() ->two() ->three() ->four() ->five(); $rootNode ->one() ->two() ->three() ->four() ->five(); $rootNode ->one() ->two() ->three() ->four() ->five(); $rootNode ->one() ->two() ->three() ->four() ->five(); // phpcs:set PEAR.WhiteSpace.ObjectOperatorIndent multilevel false PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/WhiteSpace/ObjectOperatorIndentUnitTest.inc.fixed0000644000076500000240000000337413614652361032277 0ustar gsherwoodstaffsomeFunction("some", "parameter") ->someOtherFunc(23, 42) ->someOtherFunc2($one, $two) ->someOtherFunc3(23, 42) ->andAThirdFunction(); $someObject->someFunction("some", "parameter") ->someOtherFunc(23, 42); $someObject->someFunction("some", "parameter")->someOtherFunc(23, 42); $someObject->someFunction("some", "parameter") ->someOtherFunc(23, 42); func( $bar->foo() ) ->bar(); func( $bar->foo() ) ->bar( $bar->foo() ->bar() ->func() ); $object ->setBar($foo) ->setFoo($bar); if ($bar) { $object ->setBar($foo) ->setFoo($bar); } $response -> CompletedTrackDetails -> TrackDetails -> Events; $response -> CompletedTrackDetails -> TrackDetails -> Events; $response -> CompletedTrackDetails -> TrackDetails -> Events; $var = get_object( $foo->something() ->query() )->two() ->three(); $foo->one( $foo ->two() ); get_object()->one() ->two() ->three(); someclass::one() ->two() ->three(); (new someclass())->one() ->two() ->three(); // phpcs:set PEAR.WhiteSpace.ObjectOperatorIndent multilevel true $someObject ->startSomething() ->someOtherFunc(23, 42) ->endSomething() ->doSomething(23, 42) ->endEverything(); $rootNode ->one() ->two() ->three() ->four() ->five(); $rootNode ->one() ->two() ->three() ->four() ->five(); $rootNode ->one() ->two() ->three() ->four() ->five(); $rootNode ->one() ->two() ->three() ->four() ->five(); // phpcs:set PEAR.WhiteSpace.ObjectOperatorIndent multilevel false PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/WhiteSpace/ObjectOperatorIndentUnitTest.php0000644000076500000240000000310013614652361031202 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Tests\WhiteSpace; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ObjectOperatorIndentUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 3 => 2, 6 => 1, 15 => 1, 27 => 1, 37 => 1, 38 => 1, 48 => 1, 49 => 1, 50 => 1, 65 => 1, 69 => 1, 73 => 1, 79 => 1, 80 => 1, 81 => 1, 82 => 1, 95 => 1, 103 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/WhiteSpace/ScopeClosingBraceUnitTest.inc0000644000076500000240000000422213614652361030433 0ustar gsherwoodstaff{$property} =& new $class_name($this->db_index); $this->modules[$module] =& $this->{$property}; } foreach ($elements as $element) { if ($something) { // Do IF. } else if ($somethingElse) { // Do ELSE. } } switch ($foo) { case 1: switch ($bar) { default: if ($something) { echo $string{1}; } else if ($else) { switch ($else) { case 1: // Do something. break; default: // Do something. break; } } } break; case 2: // Do something; break; } switch ($httpResponseCode) { case 100: case 101: case 102: default: return 'Unknown'; } switch ($httpResponseCode) { case 100: case 101: case 102: return 'Processing.'; default: return 'Unknown'; } switch($i) { case 1: {} } switch ($httpResponseCode) { case 100: case 101: case 102: exit; default: exit; } if ($foo): if ($bar): $foo = 1; elseif ($baz): $foo = 2; endif; endif; if ($foo): elseif ($baz): $foo = 2; endif; ?>
    getSummaryCount(); ?>
    class="empty"> PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/WhiteSpace/ScopeClosingBraceUnitTest.inc.fixed0000644000076500000240000000426413614652361031537 0ustar gsherwoodstaff{$property} =& new $class_name($this->db_index); $this->modules[$module] =& $this->{$property}; } foreach ($elements as $element) { if ($something) { // Do IF. } else if ($somethingElse) { // Do ELSE. } } switch ($foo) { case 1: switch ($bar) { default: if ($something) { echo $string{1}; } else if ($else) { switch ($else) { case 1: // Do something. break; default: // Do something. break; } } } break; case 2: // Do something; break; } switch ($httpResponseCode) { case 100: case 101: case 102: default: return 'Unknown'; } switch ($httpResponseCode) { case 100: case 101: case 102: return 'Processing.'; default: return 'Unknown'; } switch($i) { case 1: { } } switch ($httpResponseCode) { case 100: case 101: case 102: exit; default: exit; } if ($foo): if ($bar): $foo = 1; elseif ($baz): $foo = 2; endif; endif; if ($foo): elseif ($baz): $foo = 2; endif; ?>
    getSummaryCount(); ?>
    class="empty"> PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/WhiteSpace/ScopeClosingBraceUnitTest.php0000644000076500000240000000274213614652361030456 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Tests\WhiteSpace; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ScopeClosingBraceUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 11 => 1, 13 => 1, 24 => 1, 30 => 1, 61 => 1, 65 => 1, 85 => 1, 89 => 1, 98 => 1, 122 => 1, 127 => 1, 135 => 1, 141 => 1, 146 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/Tests/WhiteSpace/ScopeIndentUnitTest.inc0000644000076500000240000001346713614652361027334 0ustar gsherwoodstaffhello(); // error here } function hello() // error here { // no error here as brackets can be put anywhere in the pear standard echo 'hello'; } function hello2() { if (TRUE) { // error here echo 'hello'; // no error here as its more than 4 spaces. } else { echo 'bye'; // error here } while (TRUE) { echo 'hello'; // error here } do { // error here echo 'hello'; // error here } while (TRUE); } function hello3() { switch ($hello) { case 'hello': break; } } } ?> 
    

validate()) {
    $safe = $form->getSubmitValues();
}
?>
    open(); // error here } public function open() { // Some inline stuff that shouldn't error if (TRUE) echo 'hello'; foreach ($tokens as $token) echo $token; } /** * This is a comment 1. * This is a comment 2. * This is a comment 3. * This is a comment 4. */ public function close() { // All ok. if (TRUE) { if (TRUE) { } else if (FALSE) { foreach ($tokens as $token) { switch ($token) { case '1': case '2': if (true) { if (false) { if (false) { if (false) { echo 'hello'; } } } } break; case '5': break; } do { while (true) { foreach ($tokens as $token) { for ($i = 0; $i < $token; $i++) { echo 'hello'; } } } } while (true); } } } } /* This is another c style comment 1. This is another c style comment 2. This is another c style comment 3. This is another c style comment 4. This is another c style comment 5. */ /* * * * */ /** */ /* This comment has a newline in it. */ public function read() { echo 'hello'; // no errors below. $array = array( 'this', 'that' => array( 'hello', 'hello again' => array( 'hello', ), ), ); } } abstract class Test3 { public function parse() { foreach ($t as $ndx => $token) { if (is_array($token)) { echo 'here'; } else { $ts[] = array("token" => $token, "value" => ''); $last = count($ts) - 1; switch ($token) { case '(': if ($last >= 3 && $ts[0]['token'] != T_CLASS && $ts[$last - 2]['token'] == T_OBJECT_OPERATOR && $ts[$last - 3]['token'] == T_VARIABLE ) { if (true) { echo 'hello'; } } array_push($braces, $token); break; } } } } } function test() { $o = << * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PEAR\Tests\WhiteSpace; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ScopeIndentUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 7 => 1, 10 => 1, 17 => 1, 20 => 1, 24 => 1, 25 => 1, 27 => 1, 28 => 1, 29 => 1, 30 => 1, 58 => 1, 123 => 1, 224 => 1, 225 => 1, 279 => 1, 284 => 1, 311 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PEAR/ruleset.xml0000644000076500000240000000303513614652361021763 0ustar gsherwoodstaff The PEAR coding standard. 0 PHP_CodeSniffer-3.5.4/src/Standards/PSR1/Docs/Classes/ClassDeclarationStandard.xml0000644000076500000240000000161213614652361027456 0ustar gsherwoodstaff class Bar { } ]]> class Bar { } class Baz { } ]]> namespace Foo; class Bar { } ]]> PHP_CodeSniffer-3.5.4/src/Standards/PSR1/Docs/Files/SideEffectsStandard.xml0000644000076500000240000000113613614652361026075 0ustar gsherwoodstaff echo "Class Foo loaded." ]]> PHP_CodeSniffer-3.5.4/src/Standards/PSR1/Docs/Methods/CamelCapsMethodNameStandard.xml0000644000076500000240000000103213614652361030037 0ustar gsherwoodstaff doBar() { } } ]]> do_bar() { } } ]]> PHP_CodeSniffer-3.5.4/src/Standards/PSR1/Sniffs/Classes/ClassDeclarationSniff.php0000644000076500000240000000453113614652361027315 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR1\Sniffs\Classes; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class ClassDeclarationSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_CLASS, T_INTERFACE, T_TRAIT, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param integer $stackPtr The position of the current token in * the token stack. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['scope_closer']) === false) { return; } $errorData = [strtolower($tokens[$stackPtr]['content'])]; $nextClass = $phpcsFile->findNext([T_CLASS, T_INTERFACE, T_TRAIT], ($tokens[$stackPtr]['scope_closer'] + 1)); if ($nextClass !== false) { $error = 'Each %s must be in a file by itself'; $phpcsFile->addError($error, $nextClass, 'MultipleClasses', $errorData); $phpcsFile->recordMetric($stackPtr, 'One class per file', 'no'); } else { $phpcsFile->recordMetric($stackPtr, 'One class per file', 'yes'); } $namespace = $phpcsFile->findNext([T_NAMESPACE, T_CLASS, T_INTERFACE, T_TRAIT], 0); if ($tokens[$namespace]['code'] !== T_NAMESPACE) { $error = 'Each %s must be in a namespace of at least one level (a top-level vendor name)'; $phpcsFile->addError($error, $stackPtr, 'MissingNamespace', $errorData); $phpcsFile->recordMetric($stackPtr, 'Class defined in namespace', 'no'); } else { $phpcsFile->recordMetric($stackPtr, 'Class defined in namespace', 'yes'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR1/Sniffs/Files/SideEffectsSniff.php0000644000076500000240000002464213614652361025740 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR1\Sniffs\Files; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class SideEffectsSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the token stack. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $result = $this->searchForConflict($phpcsFile, 0, ($phpcsFile->numTokens - 1), $tokens); if ($result['symbol'] !== null && $result['effect'] !== null) { $error = 'A file should declare new symbols (classes, functions, constants, etc.) and cause no other side effects, or it should execute logic with side effects, but should not do both. The first symbol is defined on line %s and the first side effect is on line %s.'; $data = [ $tokens[$result['symbol']]['line'], $tokens[$result['effect']]['line'], ]; $phpcsFile->addWarning($error, 0, 'FoundWithSymbols', $data); $phpcsFile->recordMetric($stackPtr, 'Declarations and side effects mixed', 'yes'); } else { $phpcsFile->recordMetric($stackPtr, 'Declarations and side effects mixed', 'no'); } // Ignore the rest of the file. return ($phpcsFile->numTokens + 1); }//end process() /** * Searches for symbol declarations and side effects. * * Returns the positions of both the first symbol declared and the first * side effect in the file. A NULL value for either indicates nothing was * found. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $start The token to start searching from. * @param int $end The token to search to. * @param array $tokens The stack of tokens that make up * the file. * * @return array */ private function searchForConflict($phpcsFile, $start, $end, $tokens) { $symbols = [ T_CLASS => T_CLASS, T_INTERFACE => T_INTERFACE, T_TRAIT => T_TRAIT, T_FUNCTION => T_FUNCTION, ]; $conditions = [ T_IF => T_IF, T_ELSE => T_ELSE, T_ELSEIF => T_ELSEIF, ]; $checkAnnotations = $phpcsFile->config->annotations; $firstSymbol = null; $firstEffect = null; for ($i = $start; $i <= $end; $i++) { // Respect phpcs:disable comments. if ($checkAnnotations === true && $tokens[$i]['code'] === T_PHPCS_DISABLE && (empty($tokens[$i]['sniffCodes']) === true || isset($tokens[$i]['sniffCodes']['PSR1']) === true || isset($tokens[$i]['sniffCodes']['PSR1.Files']) === true || isset($tokens[$i]['sniffCodes']['PSR1.Files.SideEffects']) === true) ) { do { $i = $phpcsFile->findNext(T_PHPCS_ENABLE, ($i + 1)); } while ($i !== false && empty($tokens[$i]['sniffCodes']) === false && isset($tokens[$i]['sniffCodes']['PSR1']) === false && isset($tokens[$i]['sniffCodes']['PSR1.Files']) === false && isset($tokens[$i]['sniffCodes']['PSR1.Files.SideEffects']) === false); if ($i === false) { // The entire rest of the file is disabled, // so return what we have so far. break; } continue; } // Ignore whitespace and comments. if (isset(Tokens::$emptyTokens[$tokens[$i]['code']]) === true) { continue; } // Ignore PHP tags. if ($tokens[$i]['code'] === T_OPEN_TAG || $tokens[$i]['code'] === T_CLOSE_TAG ) { continue; } // Ignore shebang. if (substr($tokens[$i]['content'], 0, 2) === '#!') { continue; } // Ignore logical operators. if (isset(Tokens::$booleanOperators[$tokens[$i]['code']]) === true) { continue; } // Ignore entire namespace, declare, const and use statements. if ($tokens[$i]['code'] === T_NAMESPACE || $tokens[$i]['code'] === T_USE || $tokens[$i]['code'] === T_DECLARE || $tokens[$i]['code'] === T_CONST ) { if (isset($tokens[$i]['scope_opener']) === true) { $i = $tokens[$i]['scope_closer']; if ($tokens[$i]['code'] === T_ENDDECLARE) { $semicolon = $phpcsFile->findNext(Tokens::$emptyTokens, ($i + 1), null, true); if ($semicolon !== false && $tokens[$semicolon]['code'] === T_SEMICOLON) { $i = $semicolon; } } } else { $semicolon = $phpcsFile->findNext(T_SEMICOLON, ($i + 1)); if ($semicolon !== false) { $i = $semicolon; } } continue; } // Ignore function/class prefixes. if (isset(Tokens::$methodPrefixes[$tokens[$i]['code']]) === true) { continue; } // Ignore anon classes. if ($tokens[$i]['code'] === T_ANON_CLASS) { $i = $tokens[$i]['scope_closer']; continue; } // Detect and skip over symbols. if (isset($symbols[$tokens[$i]['code']]) === true && isset($tokens[$i]['scope_closer']) === true ) { if ($firstSymbol === null) { $firstSymbol = $i; } $i = $tokens[$i]['scope_closer']; continue; } else if ($tokens[$i]['code'] === T_STRING && strtolower($tokens[$i]['content']) === 'define' ) { $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($i - 1), null, true); if ($tokens[$prev]['code'] !== T_OBJECT_OPERATOR && $tokens[$prev]['code'] !== T_DOUBLE_COLON && $tokens[$prev]['code'] !== T_FUNCTION ) { if ($firstSymbol === null) { $firstSymbol = $i; } $semicolon = $phpcsFile->findNext(T_SEMICOLON, ($i + 1)); if ($semicolon !== false) { $i = $semicolon; } continue; } }//end if // Special case for defined() as it can be used to see // if a constant (a symbol) should be defined or not and // doesn't need to use a full conditional block. if ($tokens[$i]['code'] === T_STRING && strtolower($tokens[$i]['content']) === 'defined' ) { $openBracket = $phpcsFile->findNext(Tokens::$emptyTokens, ($i + 1), null, true); if ($tokens[$openBracket]['code'] === T_OPEN_PARENTHESIS && isset($tokens[$openBracket]['parenthesis_closer']) === true ) { $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($i - 1), null, true); if ($tokens[$prev]['code'] !== T_OBJECT_OPERATOR && $tokens[$prev]['code'] !== T_DOUBLE_COLON && $tokens[$prev]['code'] !== T_FUNCTION ) { $i = $tokens[$openBracket]['parenthesis_closer']; continue; } } }//end if // Conditional statements are allowed in symbol files as long as the // contents is only a symbol definition. So don't count these as effects // in this case. if (isset($conditions[$tokens[$i]['code']]) === true) { if (isset($tokens[$i]['scope_opener']) === false) { // Probably an "else if", so just ignore. continue; } $result = $this->searchForConflict( $phpcsFile, ($tokens[$i]['scope_opener'] + 1), ($tokens[$i]['scope_closer'] - 1), $tokens ); if ($result['symbol'] !== null) { if ($firstSymbol === null) { $firstSymbol = $result['symbol']; } if ($result['effect'] !== null) { // Found a conflict. $firstEffect = $result['effect']; break; } } if ($firstEffect === null) { $firstEffect = $result['effect']; } $i = $tokens[$i]['scope_closer']; continue; }//end if if ($firstEffect === null) { $firstEffect = $i; } if ($firstSymbol !== null) { // We have a conflict we have to report, so no point continuing. break; } }//end for return [ 'symbol' => $firstSymbol, 'effect' => $firstEffect, ]; }//end searchForConflict() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR1/Sniffs/Methods/CamelCapsMethodNameSniff.php0000644000076500000240000000613513614652361027704 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR1\Sniffs\Methods; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Standards\Generic\Sniffs\NamingConventions\CamelCapsFunctionNameSniff as GenericCamelCapsFunctionNameSniff; use PHP_CodeSniffer\Util\Common; class CamelCapsMethodNameSniff extends GenericCamelCapsFunctionNameSniff { /** * Processes the tokens within the scope. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being processed. * @param int $stackPtr The position where this token was * found. * @param int $currScope The position of the current scope. * * @return void */ protected function processTokenWithinScope(File $phpcsFile, $stackPtr, $currScope) { $tokens = $phpcsFile->getTokens(); // Determine if this is a function which needs to be examined. $conditions = $tokens[$stackPtr]['conditions']; end($conditions); $deepestScope = key($conditions); if ($deepestScope !== $currScope) { return; } $methodName = $phpcsFile->getDeclarationName($stackPtr); if ($methodName === null) { // Ignore closures. return; } // Ignore magic methods. if (preg_match('|^__[^_]|', $methodName) !== 0) { $magicPart = strtolower(substr($methodName, 2)); if (isset($this->magicMethods[$magicPart]) === true || isset($this->methodsDoubleUnderscore[$magicPart]) === true ) { return; } } $testName = ltrim($methodName, '_'); if ($testName !== '' && Common::isCamelCaps($testName, false, true, false) === false) { $error = 'Method name "%s" is not in camel caps format'; $className = $phpcsFile->getDeclarationName($currScope); if (isset($className) === false) { $className = '[Anonymous Class]'; } $errorData = [$className.'::'.$methodName]; $phpcsFile->addError($error, $stackPtr, 'NotCamelCaps', $errorData); $phpcsFile->recordMetric($stackPtr, 'CamelCase method name', 'no'); } else { $phpcsFile->recordMetric($stackPtr, 'CamelCase method name', 'yes'); } }//end processTokenWithinScope() /** * Processes the tokens outside the scope. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being processed. * @param int $stackPtr The position where this token was * found. * * @return void */ protected function processTokenOutsideScope(File $phpcsFile, $stackPtr) { }//end processTokenOutsideScope() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR1/Tests/Classes/ClassDeclarationUnitTest.1.inc0000644000076500000240000000004013614652361030011 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR1\Tests\Classes; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ClassDeclarationUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='') { if ($testFile === 'ClassDeclarationUnitTest.2.inc') { return []; } return [ 2 => 1, 3 => 2, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR1/Tests/Files/SideEffectsUnitTest.1.inc0000644000076500000240000000212013614652361026430 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/PSR1/Tests/Files/SideEffectsUnitTest.2.inc0000644000076500000240000000046313614652361026441 0ustar gsherwoodstaffdefine(); echo $object -> define(); Foo::define(); $c = new class extends Something{ public function someMethod() { // ... } }; PHP_CodeSniffer-3.5.4/src/Standards/PSR1/Tests/Files/SideEffectsUnitTest.3.inc0000644000076500000240000000015313614652361026436 0ustar gsherwoodstaff '; } printHead(); ?> PHP_CodeSniffer-3.5.4/src/Standards/PSR1/Tests/Files/SideEffectsUnitTest.5.inc0000644000076500000240000000005313614652361026437 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/PSR1/Tests/Files/SideEffectsUnitTest.6.inc0000644000076500000240000000025013614652361026437 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR1\Tests\Files; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class SideEffectsUnitTest extends AbstractSniffUnitTest { /** * Set CLI values before the file is tested. * * @param string $testFile The name of the file being tested. * @param \PHP_CodeSniffer\Config $config The config data for the test run. * * @return void */ public function setCliValues($testFile, $config) { if ($testFile === 'SideEffectsUnitTest.12.inc') { $config->annotations = false; } }//end setCliValues() /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='') { return []; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getWarningList($testFile='') { switch ($testFile) { case 'SideEffectsUnitTest.3.inc': case 'SideEffectsUnitTest.4.inc': case 'SideEffectsUnitTest.5.inc': case 'SideEffectsUnitTest.10.inc': case 'SideEffectsUnitTest.12.inc': return [1 => 1]; default: return []; }//end switch }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR1/Tests/Methods/CamelCapsMethodNameUnitTest.inc0000644000076500000240000000312613614652361030247 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR1\Tests\Methods; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class CamelCapsMethodNameUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 6 => 1, 7 => 1, 11 => 1, 12 => 1, 13 => 1, 17 => 1, 21 => 1, 25 => 1, 26 => 1, 77 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR1/ruleset.xml0000644000076500000240000000337513614652361021770 0ustar gsherwoodstaff The PSR1 coding standard. 0 PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Docs/Classes/ClassInstantiationStandard.xml0000644000076500000240000000077013614652361030143 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Docs/Functions/NullableTypeDeclarationStandard.xml0000644000076500000240000000202613614652361031446 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Docs/Keywords/ShortFormTypeKeywordsStandard.xml0000644000076500000240000000102113614652361031046 0ustar gsherwoodstaff (boolean) $isValid; ]]> PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Docs/Namespaces/CompoundNamespaceDepthStandard.xml0000644000076500000240000000126013614652361031374 0ustar gsherwoodstaff SubnamespaceOne\AnotherNamespace\ClassA, SubnamespaceOne\ClassB, ClassZ, }; ]]> PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Docs/Operators/OperatorSpacingStandard.xml0000644000076500000240000000160513614652361030010 0ustar gsherwoodstaff $b) { $variable = $foo ? 'foo' : 'bar'; } ]]> $b) { $variable=$foo?'foo':'bar'; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Sniffs/Classes/AnonClassDeclarationSniff.php0000644000076500000240000002244213614652361030214 0ustar gsherwoodstaff * @copyright 2006-2019 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Sniffs\Classes; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Standards\Generic\Sniffs\Functions\FunctionCallArgumentSpacingSniff; use PHP_CodeSniffer\Standards\PSR2\Sniffs\Classes\ClassDeclarationSniff; use PHP_CodeSniffer\Standards\Squiz\Sniffs\Functions\MultiLineFunctionDeclarationSniff; use PHP_CodeSniffer\Util\Tokens; class AnonClassDeclarationSniff extends ClassDeclarationSniff { /** * The PSR2 MultiLineFunctionDeclarations sniff. * * @var MultiLineFunctionDeclarationSniff */ private $multiLineSniff = null; /** * The Generic FunctionCallArgumentSpacing sniff. * * @var FunctionCallArgumentSpacingSniff */ private $functionCallSniff = null; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_ANON_CLASS]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['scope_opener']) === false) { return; } $this->multiLineSniff = new MultiLineFunctionDeclarationSniff(); $this->functionCallSniff = new FunctionCallArgumentSpacingSniff(); $this->processOpen($phpcsFile, $stackPtr); $this->processClose($phpcsFile, $stackPtr); if (isset($tokens[$stackPtr]['parenthesis_opener']) === true) { $openBracket = $tokens[$stackPtr]['parenthesis_opener']; if ($this->multiLineSniff->isMultiLineDeclaration($phpcsFile, $stackPtr, $openBracket, $tokens) === true) { $this->processMultiLineArgumentList($phpcsFile, $stackPtr); } else { $this->processSingleLineArgumentList($phpcsFile, $stackPtr); } $this->functionCallSniff->checkSpacing($phpcsFile, $stackPtr, $openBracket); } $opener = $tokens[$stackPtr]['scope_opener']; if ($tokens[$opener]['line'] === $tokens[$stackPtr]['line']) { return; } $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($opener - 1), $stackPtr, true); $implements = $phpcsFile->findPrevious(T_IMPLEMENTS, ($opener - 1), $stackPtr); if ($implements !== false && $tokens[$opener]['line'] !== $tokens[$implements]['line'] && $tokens[$opener]['line'] === $tokens[$prev]['line'] ) { // Opening brace must be on a new line as implements list wraps. $error = 'Opening brace must be on the line after the last implemented interface'; $fix = $phpcsFile->addFixableError($error, $opener, 'OpenBraceSameLine'); if ($fix === true) { $first = $phpcsFile->findFirstOnLine(T_WHITESPACE, $stackPtr, true); $indent = str_repeat(' ', ($tokens[$first]['column'] - 1)); $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->replaceToken(($prev + 1), ''); $phpcsFile->fixer->addNewline($prev); $phpcsFile->fixer->addContentBefore($opener, $indent); $phpcsFile->fixer->endChangeset(); } } if ($tokens[$opener]['line'] > ($tokens[$prev]['line'] + 1)) { // Opening brace is on a new line, so there must be no blank line before it. $error = 'Opening brace must not be preceded by a blank line'; $fix = $phpcsFile->addFixableError($error, $opener, 'OpenBraceLine'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($x = ($prev + 1); $x < $opener; $x++) { if ($tokens[$x]['line'] === $tokens[$prev]['line']) { // Maintain existing newline. continue; } if ($tokens[$x]['line'] === $tokens[$opener]['line']) { // Maintain existing indent. break; } $phpcsFile->fixer->replaceToken($x, ''); } $phpcsFile->fixer->endChangeset(); } }//end if }//end process() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function processSingleLineArgumentList(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $openBracket = $tokens[$stackPtr]['parenthesis_opener']; $closeBracket = $tokens[$openBracket]['parenthesis_closer']; if ($openBracket === ($closeBracket - 1)) { return; } if ($tokens[($openBracket + 1)]['code'] === T_WHITESPACE) { $error = 'Space after opening parenthesis of single-line argument list prohibited'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceAfterOpenBracket'); if ($fix === true) { $phpcsFile->fixer->replaceToken(($openBracket + 1), ''); } } $spaceBeforeClose = 0; $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($closeBracket - 1), $openBracket, true); if ($tokens[$prev]['code'] === T_END_HEREDOC || $tokens[$prev]['code'] === T_END_NOWDOC) { // Need a newline after these tokens, so ignore this rule. return; } if ($tokens[$prev]['line'] !== $tokens[$closeBracket]['line']) { $spaceBeforeClose = 'newline'; } else if ($tokens[($closeBracket - 1)]['code'] === T_WHITESPACE) { $spaceBeforeClose = $tokens[($closeBracket - 1)]['length']; } if ($spaceBeforeClose !== 0) { $error = 'Space before closing parenthesis of single-line argument list prohibited'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceBeforeCloseBracket'); if ($fix === true) { if ($spaceBeforeClose === 'newline') { $phpcsFile->fixer->beginChangeset(); $closingContent = ')'; $next = $phpcsFile->findNext(T_WHITESPACE, ($closeBracket + 1), null, true); if ($tokens[$next]['code'] === T_SEMICOLON) { $closingContent .= ';'; for ($i = ($closeBracket + 1); $i <= $next; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } } // We want to jump over any whitespace or inline comment and // move the closing parenthesis after any other token. $prev = ($closeBracket - 1); while (isset(Tokens::$emptyTokens[$tokens[$prev]['code']]) === true) { if (($tokens[$prev]['code'] === T_COMMENT) && (strpos($tokens[$prev]['content'], '*/') !== false) ) { break; } $prev--; } $phpcsFile->fixer->addContent($prev, $closingContent); $prevNonWhitespace = $phpcsFile->findPrevious(T_WHITESPACE, ($closeBracket - 1), null, true); for ($i = ($prevNonWhitespace + 1); $i <= $closeBracket; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } else { $phpcsFile->fixer->replaceToken(($closeBracket - 1), ''); }//end if }//end if }//end if }//end processSingleLineArgumentList() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function processMultiLineArgumentList(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $openBracket = $tokens[$stackPtr]['parenthesis_opener']; $this->multiLineSniff->processBracket($phpcsFile, $openBracket, $tokens, 'argument'); $this->multiLineSniff->processArgumentList($phpcsFile, $stackPtr, $this->indent, 'argument'); }//end processMultiLineArgumentList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Sniffs/Classes/ClassInstantiationSniff.php0000644000076500000240000000546113614652361030001 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Sniffs\Classes; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class ClassInstantiationSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_NEW]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Find the class name. $allowed = [ T_STRING => T_STRING, T_NS_SEPARATOR => T_NS_SEPARATOR, T_SELF => T_SELF, T_STATIC => T_STATIC, T_VARIABLE => T_VARIABLE, T_DOLLAR => T_DOLLAR, T_OBJECT_OPERATOR => T_OBJECT_OPERATOR, T_DOUBLE_COLON => T_DOUBLE_COLON, ]; $allowed += Tokens::$emptyTokens; $classNameEnd = null; for ($i = ($stackPtr + 1); $i < $phpcsFile->numTokens; $i++) { if (isset($allowed[$tokens[$i]['code']]) === true) { continue; } if ($tokens[$i]['code'] === T_OPEN_SQUARE_BRACKET || $tokens[$i]['code'] === T_OPEN_CURLY_BRACKET ) { $i = $tokens[$i]['bracket_closer']; continue; } $classNameEnd = $i; break; } if ($classNameEnd === null) { return; } if ($tokens[$classNameEnd]['code'] === T_ANON_CLASS) { // Ignore anon classes. return; } if ($tokens[$classNameEnd]['code'] === T_OPEN_PARENTHESIS) { // Using parenthesis. return; } $error = 'Parentheses must be used when instantiating a new class'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'MissingParentheses'); if ($fix === true) { $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($classNameEnd - 1), null, true); $phpcsFile->fixer->addContent($prev, '()'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Sniffs/Classes/ClosingBraceSniff.php0000644000076500000240000000337713614652361026526 0ustar gsherwoodstaff * @copyright 2006-2019 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Sniffs\Classes; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class ClosingBraceSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_CLASS, T_INTERFACE, T_TRAIT, T_FUNCTION, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['scope_closer']) === false) { return; } $closer = $tokens[$stackPtr]['scope_closer']; $next = $phpcsFile->findNext(T_WHITESPACE, ($closer + 1), null, true); if ($next === false || $tokens[$next]['line'] !== $tokens[$closer]['line'] ) { return; } $error = 'Closing brace must not be followed by any comment or statement on the same line'; $phpcsFile->addError($error, $closer, 'StatementAfter'); }//end process() }//end class ././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Sniffs/ControlStructures/BooleanOperatorPlacementSniff.phpPHP_CodeSniffer-3.5.4/src/Standards/PSR12/Sniffs/ControlStructures/BooleanOperatorPlacementSniff.php0000644000076500000240000001543313614652361033242 0ustar gsherwoodstaff * @copyright 2006-2019 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Sniffs\ControlStructures; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class BooleanOperatorPlacementSniff implements Sniff { /** * Used to restrict the placement of the boolean operator. * * Allowed value are "first" or "last". * * @var string|null */ public $allowOnly = null; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_IF, T_WHILE, T_SWITCH, T_ELSEIF, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['parenthesis_opener']) === false || isset($tokens[$stackPtr]['parenthesis_closer']) === false ) { return; } $parenOpener = $tokens[$stackPtr]['parenthesis_opener']; $parenCloser = $tokens[$stackPtr]['parenthesis_closer']; if ($tokens[$parenOpener]['line'] === $tokens[$parenCloser]['line']) { // Conditions are all on the same line. return; } $find = [ T_BOOLEAN_AND, T_BOOLEAN_OR, ]; if ($this->allowOnly === 'first' || $this->allowOnly === 'last') { $position = $this->allowOnly; } else { $position = null; } $operator = $parenOpener; $error = false; $operators = []; do { $operator = $phpcsFile->findNext($find, ($operator + 1), $parenCloser); if ($operator === false) { break; } $operators[] = $operator; $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($operator - 1), $parenOpener, true); if ($prev === false) { // Parse error. return; } if ($tokens[$prev]['line'] < $tokens[$operator]['line']) { // The boolean operator is the first content on the line. if ($position === null) { $position = 'first'; } if ($position !== 'first') { $error = true; } continue; } $next = $phpcsFile->findNext(T_WHITESPACE, ($operator + 1), $parenCloser, true); if ($next === false) { // Parse error. return; } if ($tokens[$next]['line'] > $tokens[$operator]['line']) { // The boolean operator is the last content on the line. if ($position === null) { $position = 'last'; } if ($position !== 'last') { $error = true; } continue; } } while ($operator !== false); if ($error === false) { return; } $error = 'Boolean operators between conditions must be at the beginning or end of the line, but not both'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'FoundMixed'); if ($fix === false) { return; } $phpcsFile->fixer->beginChangeset(); foreach ($operators as $operator) { $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($operator - 1), $parenOpener, true); $next = $phpcsFile->findNext(T_WHITESPACE, ($operator + 1), $parenCloser, true); if ($position === 'last') { if ($tokens[$next]['line'] === $tokens[$operator]['line']) { if ($tokens[$prev]['line'] === $tokens[$operator]['line']) { // Move the content after the operator to the next line. if ($tokens[($operator + 1)]['code'] === T_WHITESPACE) { $phpcsFile->fixer->replaceToken(($operator + 1), ''); } $first = $phpcsFile->findFirstOnLine(T_WHITESPACE, $operator, true); $padding = str_repeat(' ', ($tokens[$first]['column'] - 1)); $phpcsFile->fixer->addContent($operator, $phpcsFile->eolChar.$padding); } else { // Move the operator to the end of the previous line. if ($tokens[($operator + 1)]['code'] === T_WHITESPACE) { $phpcsFile->fixer->replaceToken(($operator + 1), ''); } $phpcsFile->fixer->addContent($prev, ' '.$tokens[$operator]['content']); $phpcsFile->fixer->replaceToken($operator, ''); } }//end if } else { if ($tokens[$prev]['line'] === $tokens[$operator]['line']) { if ($tokens[$next]['line'] === $tokens[$operator]['line']) { // Move the operator, and the rest of the expression, to the next line. if ($tokens[($operator - 1)]['code'] === T_WHITESPACE) { $phpcsFile->fixer->replaceToken(($operator - 1), ''); } $first = $phpcsFile->findFirstOnLine(T_WHITESPACE, $operator, true); $padding = str_repeat(' ', ($tokens[$first]['column'] - 1)); $phpcsFile->fixer->addContentBefore($operator, $phpcsFile->eolChar.$padding); } else { // Move the operator to the start of the next line. if ($tokens[($operator - 1)]['code'] === T_WHITESPACE) { $phpcsFile->fixer->replaceToken(($operator - 1), ''); } $phpcsFile->fixer->addContentBefore($next, $tokens[$operator]['content'].' '); $phpcsFile->fixer->replaceToken($operator, ''); } }//end if }//end if }//end foreach $phpcsFile->fixer->endChangeset(); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Sniffs/ControlStructures/ControlStructureSpacingSniff.php0000644000076500000240000001573513614652361033171 0ustar gsherwoodstaff * @copyright 2006-2019 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Sniffs\ControlStructures; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Standards\PSR2\Sniffs\ControlStructures\ControlStructureSpacingSniff as PSR2Spacing; use PHP_CodeSniffer\Util\Tokens; class ControlStructureSpacingSniff implements Sniff { /** * The number of spaces code should be indented. * * @var integer */ public $indent = 4; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_IF, T_WHILE, T_FOREACH, T_FOR, T_SWITCH, T_ELSE, T_ELSEIF, T_CATCH, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['parenthesis_opener']) === false || isset($tokens[$stackPtr]['parenthesis_closer']) === false ) { return; } $parenOpener = $tokens[$stackPtr]['parenthesis_opener']; $parenCloser = $tokens[$stackPtr]['parenthesis_closer']; if ($tokens[$parenOpener]['line'] === $tokens[$parenCloser]['line']) { // Conditions are all on the same line, so follow PSR2. $sniff = new PSR2Spacing(); return $sniff->process($phpcsFile, $stackPtr); } $next = $phpcsFile->findNext(T_WHITESPACE, ($parenOpener + 1), $parenCloser, true); if ($next === false) { // No conditions; parse error. return; } // Check the first expression. if ($tokens[$next]['line'] !== ($tokens[$parenOpener]['line'] + 1)) { $error = 'The first expression of a multi-line control structure must be on the line after the opening parenthesis'; $fix = $phpcsFile->addFixableError($error, $next, 'FirstExpressionLine'); if ($fix === true) { $phpcsFile->fixer->addNewline($parenOpener); } } // Check the indent of each line. $first = $phpcsFile->findFirstOnLine(T_WHITESPACE, $stackPtr, true); $requiredIndent = ($tokens[$first]['column'] + $this->indent - 1); for ($i = $parenOpener; $i < $parenCloser; $i++) { if ($tokens[$i]['column'] !== 1 || $tokens[($i + 1)]['line'] > $tokens[$i]['line'] || isset(Tokens::$commentTokens[$tokens[$i]['code']]) === true ) { continue; } if (($i + 1) === $parenCloser) { break; } // Leave indentation inside multi-line strings. if (isset(Tokens::$textStringTokens[$tokens[$i]['code']]) === true || isset(Tokens::$heredocTokens[$tokens[$i]['code']]) === true ) { continue; } if ($tokens[$i]['code'] !== T_WHITESPACE) { $foundIndent = 0; } else { $foundIndent = $tokens[$i]['length']; } if ($foundIndent < $requiredIndent) { $error = 'Each line in a multi-line control structure must be indented at least once; expected at least %s spaces, but found %s'; $data = [ $requiredIndent, $foundIndent, ]; $fix = $phpcsFile->addFixableError($error, $i, 'LineIndent', $data); if ($fix === true) { $padding = str_repeat(' ', $requiredIndent); if ($foundIndent === 0) { $phpcsFile->fixer->addContentBefore($i, $padding); } else { $phpcsFile->fixer->replaceToken($i, $padding); } } } }//end for // Check the closing parenthesis. $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($parenCloser - 1), $parenOpener, true); if ($tokens[$parenCloser]['line'] !== ($tokens[$prev]['line'] + 1)) { $error = 'The closing parenthesis of a multi-line control structure must be on the line after the last expression'; $fix = $phpcsFile->addFixableError($error, $parenCloser, 'CloseParenthesisLine'); if ($fix === true) { if ($tokens[$parenCloser]['line'] === $tokens[$prev]['line']) { $phpcsFile->fixer->addNewlineBefore($parenCloser); } else { $phpcsFile->fixer->beginChangeset(); for ($i = ($prev + 1); $i < $parenCloser; $i++) { // Maintain existing newline. if ($tokens[$i]['line'] === $tokens[$prev]['line']) { continue; } // Maintain existing indent. if ($tokens[$i]['line'] === $tokens[$parenCloser]['line']) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } }//end if }//end if if ($tokens[$parenCloser]['line'] !== $tokens[$prev]['line']) { $requiredIndent = ($tokens[$first]['column'] - 1); $foundIndent = ($tokens[$parenCloser]['column'] - 1); if ($foundIndent !== $requiredIndent) { $error = 'The closing parenthesis of a multi-line control structure must be indented to the same level as start of the control structure; expected %s spaces but found %s'; $data = [ $requiredIndent, $foundIndent, ]; $fix = $phpcsFile->addFixableError($error, $parenCloser, 'CloseParenthesisIndent', $data); if ($fix === true) { $padding = str_repeat(' ', $requiredIndent); if ($foundIndent === 0) { $phpcsFile->fixer->addContentBefore($parenCloser, $padding); } else { $phpcsFile->fixer->replaceToken(($parenCloser - 1), $padding); } } } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Sniffs/Files/DeclareStatementSniff.php0000644000076500000240000002742713614652361027066 0ustar gsherwoodstaff * @copyright 2006-2019 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Sniffs\Files; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class DeclareStatementSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_DECLARE]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { // Allow a byte-order mark. $tokens = $phpcsFile->getTokens(); // There should be no space between declare keyword and opening parenthesis. $parenthesis = ($stackPtr + 1); if ($tokens[($stackPtr + 1)]['type'] !== 'T_OPEN_PARENTHESIS') { $parenthesis = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); $error = 'Expected no space between declare keyword and opening parenthesis in a declare statement'; if ($tokens[$parenthesis]['type'] === 'T_OPEN_PARENTHESIS') { $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceFoundAfterDeclare'); if ($fix === true) { $phpcsFile->fixer->replaceToken(($stackPtr + 1), ''); } } else { $phpcsFile->addError($error, $parenthesis, 'SpaceFoundAfterDeclare'); $parenthesis = $phpcsFile->findNext(T_OPEN_PARENTHESIS, ($parenthesis + 1)); } } // There should be no space between open parenthesis and the directive. $string = $phpcsFile->findNext(T_WHITESPACE, ($parenthesis + 1), null, true); if ($parenthesis !== false) { if ($tokens[($parenthesis + 1)]['type'] !== 'T_STRING') { $error = 'Expected no space between opening parenthesis and directive in a declare statement'; if ($tokens[$string]['type'] === 'T_STRING') { $fix = $phpcsFile->addFixableError($error, $parenthesis, 'SpaceFoundBeforeDirective'); if ($fix === true) { $phpcsFile->fixer->replaceToken(($parenthesis + 1), ''); } } else { $phpcsFile->addError($error, $string, 'SpaceFoundBeforeDirective'); $string = $phpcsFile->findNext(T_STRING, ($string + 1)); } } } // There should be no space between directive and the equal sign. $equals = $phpcsFile->findNext(T_WHITESPACE, ($string + 1), null, true); if ($string !== false) { // The directive must be in lowercase. if ($tokens[$string]['content'] !== strtolower($tokens[$string]['content'])) { $error = 'The directive of a declare statement must be in lowercase'; $fix = $phpcsFile->addFixableError($error, $string, 'DirectiveNotLowercase'); if ($fix === true) { $phpcsFile->fixer->replaceToken($string, strtolower($tokens[$string]['content'])); } } if ($tokens[($string + 1)]['type'] !== 'T_EQUAL') { $error = 'Expected no space between directive and the equals sign in a declare statement'; if ($tokens[$equals]['type'] === 'T_EQUAL') { $fix = $phpcsFile->addFixableError($error, $equals, 'SpaceFoundAfterDirective'); if ($fix === true) { $phpcsFile->fixer->replaceToken(($string + 1), ''); } } else { $phpcsFile->addError($error, $equals, 'SpaceFoundAfterDirective'); $equals = $phpcsFile->findNext(T_EQUAL, ($equals + 1)); } } }//end if // There should be no space between equal sign and directive value. $value = $phpcsFile->findNext(T_WHITESPACE, ($equals + 1), null, true); if ($equals !== false) { if ($tokens[($equals + 1)]['type'] !== 'T_LNUMBER') { $error = 'Expected no space between equal sign and the directive value in a declare statement'; if ($tokens[$value]['type'] === 'T_LNUMBER') { $fix = $phpcsFile->addFixableError($error, $value, 'SpaceFoundBeforeDirectiveValue'); if ($fix === true) { $phpcsFile->fixer->replaceToken(($equals + 1), ''); } } else { $phpcsFile->addError($error, $value, 'SpaceFoundBeforeDirectiveValue'); $value = $phpcsFile->findNext(T_LNUMBER, ($value + 1)); } } } $parenthesis = $phpcsFile->findNext(T_WHITESPACE, ($value + 1), null, true); if ($value !== false) { if ($tokens[($value + 1)]['type'] !== 'T_CLOSE_PARENTHESIS') { $error = 'Expected no space between the directive value and closing parenthesis in a declare statement'; if ($tokens[$parenthesis]['type'] === 'T_CLOSE_PARENTHESIS') { $fix = $phpcsFile->addFixableError($error, $parenthesis, 'SpaceFoundAfterDirectiveValue'); if ($fix === true) { $phpcsFile->fixer->replaceToken(($value + 1), ''); } } else { $phpcsFile->addError($error, $parenthesis, 'SpaceFoundAfterDirectiveValue'); $parenthesis = $phpcsFile->findNext(T_CLOSE_PARENTHESIS, ($parenthesis + 1)); } } } // Check for semicolon. $curlyBracket = false; if ($tokens[($parenthesis + 1)]['type'] !== 'T_SEMICOLON') { $token = $phpcsFile->findNext(T_WHITESPACE, ($parenthesis + 1), null, true); if ($tokens[$token]['type'] === 'T_OPEN_CURLY_BRACKET') { // Block declaration. $curlyBracket = $token; } else if ($tokens[$token]['type'] === 'T_SEMICOLON') { $error = 'Expected no space between the closing parenthesis and the semicolon in a declare statement'; $fix = $phpcsFile->addFixableError($error, $parenthesis, 'SpaceFoundBeforeSemicolon'); if ($fix === true) { $phpcsFile->fixer->replaceToken(($parenthesis + 1), ''); } } else if ($tokens[$token]['type'] === 'T_CLOSE_TAG') { if ($tokens[($parenthesis)]['line'] !== $tokens[$token]['line']) { // Close tag must be on the same line.. $error = 'The close tag must be on the same line as the declare statement'; $fix = $phpcsFile->addFixableError($error, $parenthesis, 'CloseTagOnNewLine'); if ($fix === true) { $phpcsFile->fixer->replaceToken(($parenthesis + 1), ' '); } } } else { $error = 'Expected no space between the closing parenthesis and the semicolon in a declare statement'; $phpcsFile->addError($error, $parenthesis, 'SpaceFoundBeforeSemicolon'); // See if there is a semicolon or curly bracket after this token. $token = $phpcsFile->findNext([T_WHITESPACE, T_COMMENT], ($token + 1), null, true); if ($tokens[$token]['type'] === 'T_OPEN_CURLY_BRACKET') { $curlyBracket = $token; } }//end if }//end if if ($curlyBracket !== false) { $prevToken = $phpcsFile->findPrevious(T_WHITESPACE, ($curlyBracket - 1), null, true); $error = 'Expected one space between closing parenthesis and opening curly bracket in a declare statement'; // The opening curly bracket must on the same line with a single space between closing bracket. if ($tokens[$prevToken]['type'] !== 'T_CLOSE_PARENTHESIS') { $phpcsFile->addError($error, $curlyBracket, 'ExtraSpaceFoundAfterBracket'); } else if ($phpcsFile->getTokensAsString(($prevToken + 1), ($curlyBracket - $prevToken - 1)) !== ' ') { $fix = $phpcsFile->addFixableError($error, $curlyBracket, 'ExtraSpaceFoundAfterBracket'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->replaceToken(($prevToken + 1), ' '); $nextToken = ($prevToken + 2); while ($nextToken !== $curlyBracket) { $phpcsFile->fixer->replaceToken($nextToken, ''); $nextToken++; } $phpcsFile->fixer->endChangeset(); } }//end if $closeCurlyBracket = $tokens[$curlyBracket]['bracket_closer']; $prevToken = $phpcsFile->findPrevious(T_WHITESPACE, ($closeCurlyBracket - 1), null, true); $nextToken = $phpcsFile->findNext([T_WHITESPACE, T_COMMENT], ($closeCurlyBracket + 1), null, true); $line = $tokens[$closeCurlyBracket]['line']; // The closing curly bracket must be on a new line. if ($tokens[$prevToken]['line'] === $line || $tokens[$nextToken]['line'] === $line) { if ($tokens[$prevToken]['line'] === $line) { $error = 'The closing curly bracket of a declare statement must be on a new line'; $fix = $phpcsFile->addFixableError($error, $prevToken, 'CurlyBracketNotOnNewLine'); if ($fix === true) { $phpcsFile->fixer->addNewline($prevToken); } } }//end if // Closing curly bracket must align with the declare keyword. if ($tokens[$stackPtr]['column'] !== $tokens[$closeCurlyBracket]['column']) { $error = 'The closing curly bracket of a declare statements must be aligned with the declare keyword'; $fix = $phpcsFile->addFixableError($error, $closeCurlyBracket, 'CloseBracketNotAligned'); if ($fix === true) { $phpcsFile->fixer->replaceToken(($closeCurlyBracket - 1), str_repeat(' ', ($tokens[$stackPtr]['column'] - 1))); } } // The open curly bracket must be the last code on the line. $token = $phpcsFile->findNext(Tokens::$emptyTokens, ($curlyBracket + 1), null, true); if ($tokens[$curlyBracket]['line'] === $tokens[$token]['line']) { $error = 'The open curly bracket of a declare statement must be the last code on the line'; $fix = $phpcsFile->addFixableError($error, $token, 'CodeFoundAfterCurlyBracket'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $prevToken = $phpcsFile->findPrevious(T_WHITESPACE, ($token - 1), null, true); for ($i = ($prevToken + 1); $i < $token; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->addNewLineBefore($token); $phpcsFile->fixer->endChangeset(); } } }//end if }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Sniffs/Files/FileHeaderSniff.php0000644000076500000240000003513413614652361025624 0ustar gsherwoodstaff * @copyright 2006-2019 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Sniffs\Files; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class FileHeaderSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes this sniff when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current * token in the stack. * * @return int|null */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $possibleHeaders = []; $searchFor = Tokens::$ooScopeTokens; $searchFor[T_OPEN_TAG] = T_OPEN_TAG; $openTag = $stackPtr; do { $headerLines = $this->getHeaderLines($phpcsFile, $openTag); if (empty($headerLines) === true && $openTag === $stackPtr) { // No content in the file. return; } $possibleHeaders[$openTag] = $headerLines; if (count($headerLines) > 1) { break; } $next = $phpcsFile->findNext($searchFor, ($openTag + 1)); if (isset(Tokens::$ooScopeTokens[$tokens[$next]['code']]) === true) { // Once we find an OO token, the file content has // definitely started. break; } $openTag = $next; } while ($openTag !== false); if ($openTag === false) { // We never found a proper file header // so use the first one as the header. $openTag = $stackPtr; } else if (count($possibleHeaders) > 1) { // There are other PHP blocks before the file header. $error = 'The file header must be the first content in the file'; $phpcsFile->addError($error, $openTag, 'HeaderPosition'); } else { // The first possible header was the file header block, // so make sure it is the first content in the file. if ($openTag !== 0) { // Allow for hashbang lines. $hashbang = false; if ($tokens[($openTag - 1)]['code'] === T_INLINE_HTML) { $content = trim($tokens[($openTag - 1)]['content']); if (substr($content, 0, 2) === '#!') { $hashbang = true; } } if ($hashbang === false) { $error = 'The file header must be the first content in the file'; $phpcsFile->addError($error, $openTag, 'HeaderPosition'); } } }//end if $this->processHeaderLines($phpcsFile, $possibleHeaders[$openTag]); return $phpcsFile->numTokens; }//end process() /** * Gather information about the statements inside a possible file header. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current * token in the stack. * * @return array */ public function getHeaderLines(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $next = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($next === false) { return []; } $headerLines = []; $headerLines[] = [ 'type' => 'tag', 'start' => $stackPtr, 'end' => $stackPtr, ]; $foundDocblock = false; $commentOpeners = Tokens::$scopeOpeners; unset($commentOpeners[T_NAMESPACE]); unset($commentOpeners[T_DECLARE]); unset($commentOpeners[T_USE]); unset($commentOpeners[T_IF]); unset($commentOpeners[T_WHILE]); unset($commentOpeners[T_FOR]); unset($commentOpeners[T_FOREACH]); unset($commentOpeners[T_DO]); unset($commentOpeners[T_TRY]); do { switch ($tokens[$next]['code']) { case T_DOC_COMMENT_OPEN_TAG: if ($foundDocblock === true) { // Found a second docblock, so start of code. break(2); } // Make sure this is not a code-level docblock. $end = $tokens[$next]['comment_closer']; $docToken = $phpcsFile->findNext(Tokens::$emptyTokens, ($end + 1), null, true); if (isset($commentOpeners[$tokens[$docToken]['code']]) === false && isset(Tokens::$methodPrefixes[$tokens[$docToken]['code']]) === false ) { // Check for an @var annotation. $annotation = false; for ($i = $next; $i < $end; $i++) { if ($tokens[$i]['code'] === T_DOC_COMMENT_TAG && strtolower($tokens[$i]['content']) === '@var' ) { $annotation = true; break; } } if ($annotation === false) { $foundDocblock = true; $headerLines[] = [ 'type' => 'docblock', 'start' => $next, 'end' => $end, ]; } }//end if $next = $end; break; case T_DECLARE: case T_NAMESPACE: $end = $phpcsFile->findEndOfStatement($next); $headerLines[] = [ 'type' => substr(strtolower($tokens[$next]['type']), 2), 'start' => $next, 'end' => $end, ]; $next = $end; break; case T_USE: $type = 'use'; $useType = $phpcsFile->findNext(Tokens::$emptyTokens, ($next + 1), null, true); if ($useType !== false && $tokens[$useType]['code'] === T_STRING) { $content = strtolower($tokens[$useType]['content']); if ($content === 'function' || $content === 'const') { $type .= ' '.$content; } } $end = $phpcsFile->findEndOfStatement($next); $headerLines[] = [ 'type' => $type, 'start' => $next, 'end' => $end, ]; $next = $end; break; default: // Skip comments as PSR-12 doesn't say if these are allowed or not. if (isset(Tokens::$commentTokens[$tokens[$next]['code']]) === true) { $next = $phpcsFile->findNext(Tokens::$commentTokens, ($next + 1), null, true); if ($next === false) { // We reached the end of the file. break(2); } $next--; break; } // We found the start of the main code block. break(2); }//end switch $next = $phpcsFile->findNext(T_WHITESPACE, ($next + 1), null, true); } while ($next !== false); return $headerLines; }//end getHeaderLines() /** * Check the spacing and grouping of the statements inside each header block. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param array $headerLines Header information, as sourced * from getHeaderLines(). * * @return int|null */ public function processHeaderLines(File $phpcsFile, $headerLines) { $tokens = $phpcsFile->getTokens(); $found = []; foreach ($headerLines as $i => $line) { if (isset($headerLines[($i + 1)]) === false || $headerLines[($i + 1)]['type'] !== $line['type'] ) { // We're at the end of the current header block. // Make sure there is a single blank line after // this block. $next = $phpcsFile->findNext(T_WHITESPACE, ($line['end'] + 1), null, true); if ($next !== false && $tokens[$next]['line'] !== ($tokens[$line['end']]['line'] + 2)) { $error = 'Header blocks must be separated by a single blank line'; $fix = $phpcsFile->addFixableError($error, $line['end'], 'SpacingAfterBlock'); if ($fix === true) { if ($tokens[$next]['line'] === $tokens[$line['end']]['line']) { $phpcsFile->fixer->addNewlineBefore($next); $phpcsFile->fixer->addNewlineBefore($next); } else if ($tokens[$next]['line'] === ($tokens[$line['end']]['line'] + 1)) { $phpcsFile->fixer->addNewline($line['end']); } else { $phpcsFile->fixer->beginChangeset(); for ($i = ($line['end'] + 1); $i < $next; $i++) { if ($tokens[$i]['line'] === ($tokens[$line['end']]['line'] + 2)) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } }//end if }//end if // Make sure we haven't seen this next block before. if (isset($headerLines[($i + 1)]) === true && isset($found[$headerLines[($i + 1)]['type']]) === true ) { $error = 'Similar statements must be grouped together inside header blocks; '; $error .= 'the first "%s" statement was found on line %s'; $data = [ $headerLines[($i + 1)]['type'], $tokens[$found[$headerLines[($i + 1)]['type']]['start']]['line'], ]; $phpcsFile->addError($error, $headerLines[($i + 1)]['start'], 'IncorrectGrouping', $data); } } else if ($headerLines[($i + 1)]['type'] === $line['type']) { // Still in the same block, so make sure there is no // blank line after this statement. $next = $phpcsFile->findNext(T_WHITESPACE, ($line['end'] + 1), null, true); if ($tokens[$next]['line'] > ($tokens[$line['end']]['line'] + 1)) { $error = 'Header blocks must not contain blank lines'; $fix = $phpcsFile->addFixableError($error, $line['end'], 'SpacingInsideBlock'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($line['end'] + 1); $i < $next; $i++) { if ($tokens[$i]['line'] === $tokens[$line['end']]['line']) { continue; } if ($tokens[$i]['line'] === $tokens[$next]['line']) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } } }//end if if (isset($found[$line['type']]) === false) { $found[$line['type']] = $line; } }//end foreach /* Next, check that the order of the header blocks is correct: Opening php tag. File-level docblock. One or more declare statements. The namespace declaration of the file. One or more class-based use import statements. One or more function-based use import statements. One or more constant-based use import statements. */ $blockOrder = [ 'tag' => 'opening PHP tag', 'docblock' => 'file-level docblock', 'declare' => 'declare statements', 'namespace' => 'namespace declaration', 'use' => 'class-based use imports', 'use function' => 'function-based use imports', 'use const' => 'constant-based use imports', ]; foreach (array_keys($found) as $type) { if ($type === 'tag') { // The opening tag is always in the correct spot. continue; } do { $orderedType = next($blockOrder); } while ($orderedType !== false && key($blockOrder) !== $type); if ($orderedType === false) { // We didn't find the block type in the rest of the // ordered array, so it is out of place. // Error and reset the array to the correct position // so we can check the next block. reset($blockOrder); $prevValidType = 'tag'; do { $orderedType = next($blockOrder); if (isset($found[key($blockOrder)]) === true && key($blockOrder) !== $type ) { $prevValidType = key($blockOrder); } } while ($orderedType !== false && key($blockOrder) !== $type); $error = 'The %s must follow the %s in the file header'; $data = [ $blockOrder[$type], $blockOrder[$prevValidType], ]; $phpcsFile->addError($error, $found[$type]['start'], 'IncorrectOrder', $data); }//end if }//end foreach }//end processHeaderLines() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Sniffs/Files/ImportStatementSniff.php0000644000076500000240000000427113614652361026771 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Sniffs\Files; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class ImportStatementSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_USE]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Make sure this is not a closure USE group. $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true); if ($tokens[$next]['code'] === T_OPEN_PARENTHESIS) { return; } if ($phpcsFile->hasCondition($stackPtr, Tokens::$ooScopeTokens) === true) { // This rule only applies to import statements. return; } if ($tokens[$next]['code'] === T_STRING && (strtolower($tokens[$next]['content']) === 'function' || strtolower($tokens[$next]['content']) === 'const') ) { $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($next + 1), null, true); } if ($tokens[$next]['code'] !== T_NS_SEPARATOR) { return; } $error = 'Import statements must not begin with a leading backslash'; $fix = $phpcsFile->addFixableError($error, $next, 'LeadingSlash'); if ($fix === true) { $phpcsFile->fixer->replaceToken($next, ''); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Sniffs/Files/OpenTagSniff.php0000644000076500000240000000376613614652361025177 0ustar gsherwoodstaff * @copyright 2006-2019 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Sniffs\Files; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class OpenTagSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes this sniff when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current * token in the stack. * * @return int */ public function process(File $phpcsFile, $stackPtr) { if ($stackPtr !== 0) { // This rule only applies if the open tag is on the first line of the file. return $phpcsFile->numTokens; } $next = $phpcsFile->findNext(T_INLINE_HTML, 0); if ($next !== false) { // This rule only applies to PHP-only files. return $phpcsFile->numTokens; } $tokens = $phpcsFile->getTokens(); $next = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($next === false) { // Empty file. return; } if ($tokens[$next]['line'] === $tokens[$stackPtr]['line']) { $error = 'Opening PHP tag must be on a line by itself'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NotAlone'); if ($fix === true) { $phpcsFile->fixer->addNewline($stackPtr); } } return $phpcsFile->numTokens; }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Sniffs/Functions/NullableTypeDeclarationSniff.php0000644000076500000240000000520413614652361031303 0ustar gsherwoodstaff * @copyright 2006-2018 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Sniffs\Functions; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class NullableTypeDeclarationSniff implements Sniff { /** * An array of valid tokens after `T_NULLABLE` occurrences. * * @var array */ private $validTokens = [ T_STRING => true, T_NS_SEPARATOR => true, T_CALLABLE => true, T_SELF => true, T_PARENT => true, ]; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_NULLABLE]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $nextNonEmptyPtr = $phpcsFile->findNext([T_WHITESPACE], ($stackPtr + 1), null, true); if ($nextNonEmptyPtr === false) { // Parse error or live coding. return; } $tokens = $phpcsFile->getTokens(); $nextNonEmptyCode = $tokens[$nextNonEmptyPtr]['code']; $validTokenFound = isset($this->validTokens[$nextNonEmptyCode]); if ($validTokenFound === true && $nextNonEmptyPtr === ($stackPtr + 1)) { // Valid structure. return; } $error = 'There must not be a space between the question mark and the type in nullable type declarations'; if ($validTokenFound === true) { // No other tokens then whitespace tokens found; fixable. $fix = $phpcsFile->addFixableError($error, $stackPtr, 'WhitespaceFound'); if ($fix === true) { for ($i = ($stackPtr + 1); $i < $nextNonEmptyPtr; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } } return; } // Non-whitespace tokens found; trigger error but don't fix. $phpcsFile->addError($error, $stackPtr, 'UnexpectedCharactersFound'); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Sniffs/Functions/ReturnTypeDeclarationSniff.php0000644000076500000240000000760513614652361031033 0ustar gsherwoodstaff * @copyright 2006-2019 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Sniffs\Functions; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class ReturnTypeDeclarationSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_FUNCTION, T_CLOSURE, T_FN, ]; }//end register() /** * Processes this test when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['parenthesis_opener']) === false || isset($tokens[$stackPtr]['parenthesis_closer']) === false || $tokens[$stackPtr]['parenthesis_opener'] === null || $tokens[$stackPtr]['parenthesis_closer'] === null ) { return; } $methodProperties = $phpcsFile->getMethodProperties($stackPtr); if ($methodProperties['return_type'] === '') { return; } $returnType = $methodProperties['return_type_token']; if ($methodProperties['nullable_return_type'] === true) { $returnType = $phpcsFile->findPrevious(T_NULLABLE, ($returnType - 1)); } if ($tokens[($returnType - 1)]['code'] !== T_WHITESPACE || $tokens[($returnType - 1)]['content'] !== ' ' || $tokens[($returnType - 2)]['code'] !== T_COLON ) { $error = 'There must be a single space between the colon and type in a return type declaration'; if ($tokens[($returnType - 1)]['code'] === T_WHITESPACE && $tokens[($returnType - 2)]['code'] === T_COLON ) { $fix = $phpcsFile->addFixableError($error, $returnType, 'SpaceBeforeReturnType'); if ($fix === true) { $phpcsFile->fixer->replaceToken(($returnType - 1), ' '); } } else if ($tokens[($returnType - 1)]['code'] === T_COLON) { $fix = $phpcsFile->addFixableError($error, $returnType, 'SpaceBeforeReturnType'); if ($fix === true) { $phpcsFile->fixer->addContentBefore($returnType, ' '); } } else { $phpcsFile->addError($error, $returnType, 'SpaceBeforeReturnType'); } } $colon = $phpcsFile->findPrevious(T_COLON, $returnType); if ($tokens[($colon - 1)]['code'] !== T_CLOSE_PARENTHESIS) { $error = 'There must not be a space before the colon in a return type declaration'; $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($colon - 1), null, true); if ($tokens[$prev]['code'] === T_CLOSE_PARENTHESIS) { $fix = $phpcsFile->addFixableError($error, $colon, 'SpaceBeforeColon'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($x = ($prev + 1); $x < $colon; $x++) { $phpcsFile->fixer->replaceToken($x, ''); } $phpcsFile->fixer->endChangeset(); } } else { $phpcsFile->addError($error, $colon, 'SpaceBeforeColon'); } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Sniffs/Keywords/ShortFormTypeKeywordsSniff.php0000644000076500000240000000436513614652361030720 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Sniffs\Keywords; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class ShortFormTypeKeywordsSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_BOOL_CAST, T_INT_CAST, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $typecast = str_replace(' ', '', $tokens[$stackPtr]['content']); $typecast = str_replace("\t", '', $typecast); $typecast = trim($typecast, '()'); $typecastLc = strtolower($typecast); if (($tokens[$stackPtr]['code'] === T_BOOL_CAST && $typecastLc === 'bool') || ($tokens[$stackPtr]['code'] === T_INT_CAST && $typecastLc === 'int') ) { return; } $error = 'Short form type keywords must be used. Found: %s'; $data = [$tokens[$stackPtr]['content']]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'LongFound', $data); if ($fix === true) { if ($tokens[$stackPtr]['code'] === T_BOOL_CAST) { $replacement = str_replace($typecast, 'bool', $tokens[$stackPtr]['content']); } else { $replacement = str_replace($typecast, 'int', $tokens[$stackPtr]['content']); } $phpcsFile->fixer->replaceToken($stackPtr, $replacement); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Sniffs/Namespaces/CompoundNamespaceDepthSniff.php0000644000076500000240000000410113614652361031225 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Sniffs\Namespaces; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class CompoundNamespaceDepthSniff implements Sniff { /** * The max depth for compound namespaces. * * @var integer */ public $maxDepth = 2; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_OPEN_USE_GROUP]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $this->maxDepth = (int) $this->maxDepth; $tokens = $phpcsFile->getTokens(); $end = $phpcsFile->findNext(T_CLOSE_USE_GROUP, ($stackPtr + 1)); if ($end === false) { return; } $depth = 1; for ($i = ($stackPtr + 1); $i <= $end; $i++) { if ($tokens[$i]['code'] === T_NS_SEPARATOR) { $depth++; continue; } if ($i === $end || $tokens[$i]['code'] === T_COMMA) { // End of a namespace. if ($depth > $this->maxDepth) { $error = 'Compound namespaces cannot have a depth more than %s'; $data = [$this->maxDepth]; $phpcsFile->addError($error, $i, 'TooDeep', $data); } $depth = 1; } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Sniffs/Operators/OperatorSpacingSniff.php0000644000076500000240000000671413614652361027652 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Sniffs\Operators; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Standards\Squiz\Sniffs\WhiteSpace\OperatorSpacingSniff as SquizOperatorSpacingSniff; use PHP_CodeSniffer\Util\Tokens; class OperatorSpacingSniff extends SquizOperatorSpacingSniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { parent::register(); $targets = Tokens::$comparisonTokens; $targets += Tokens::$operators; $targets += Tokens::$assignmentTokens; $targets += Tokens::$booleanOperators; $targets[] = T_INLINE_THEN; $targets[] = T_INLINE_ELSE; $targets[] = T_STRING_CONCAT; $targets[] = T_INSTANCEOF; return $targets; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being checked. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if ($this->isOperator($phpcsFile, $stackPtr) === false) { return; } $operator = $tokens[$stackPtr]['content']; $checkBefore = true; $checkAfter = true; // Skip short ternary. if ($tokens[($stackPtr)]['code'] === T_INLINE_ELSE && $tokens[($stackPtr - 1)]['code'] === T_INLINE_THEN ) { $checkBefore = false; } // Skip operator with comment on previous line. if ($tokens[($stackPtr - 1)]['code'] === T_COMMENT && $tokens[($stackPtr - 1)]['line'] < $tokens[$stackPtr]['line'] ) { $checkBefore = false; } if (isset($tokens[($stackPtr + 1)]) === true) { // Skip short ternary. if ($tokens[$stackPtr]['code'] === T_INLINE_THEN && $tokens[($stackPtr + 1)]['code'] === T_INLINE_ELSE ) { $checkAfter = false; } } else { // Skip partial files. $checkAfter = false; } if ($checkBefore === true && $tokens[($stackPtr - 1)]['code'] !== T_WHITESPACE) { $error = 'Expected at least 1 space before "%s"; 0 found'; $data = [$operator]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NoSpaceBefore', $data); if ($fix === true) { $phpcsFile->fixer->addContentBefore($stackPtr, ' '); } } if ($checkAfter === true && $tokens[($stackPtr + 1)]['code'] !== T_WHITESPACE) { $error = 'Expected at least 1 space after "%s"; 0 found'; $data = [$operator]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NoSpaceAfter', $data); if ($fix === true) { $phpcsFile->fixer->addContent($stackPtr, ' '); } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Sniffs/Properties/ConstantVisibilitySniff.php0000644000076500000240000000331513614652361030563 0ustar gsherwoodstaff * @copyright 2006-2019 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Sniffs\Properties; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class ConstantVisibilitySniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_CONST]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Make sure this is a class constant. if ($phpcsFile->hasCondition($stackPtr, Tokens::$ooScopeTokens) === false) { return; } $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); if (isset(Tokens::$scopeModifiers[$tokens[$prev]['code']]) === true) { return; } $error = 'Visibility must be declared on all constants if your project supports PHP 7.1 or later'; $phpcsFile->addWarning($error, $stackPtr, 'NotFound'); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Sniffs/Traits/UseDeclarationSniff.php0000644000076500000240000007674513614652361026757 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Sniffs\Traits; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class UseDeclarationSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_USE]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Needs to be a use statement directly inside a class. $conditions = $tokens[$stackPtr]['conditions']; end($conditions); if (isset(Tokens::$ooScopeTokens[current($conditions)]) === false) { return; } $ooToken = key($conditions); $opener = $tokens[$ooToken]['scope_opener']; // Figure out where all the use statements are. $useTokens = [$stackPtr]; for ($i = ($stackPtr + 1); $i < $tokens[$ooToken]['scope_closer']; $i++) { if ($tokens[$i]['code'] === T_USE) { $useTokens[] = $i; } if (isset($tokens[$i]['scope_closer']) === true) { $i = $tokens[$i]['scope_closer']; } } $numUseTokens = count($useTokens); foreach ($useTokens as $usePos => $useToken) { if ($usePos === 0) { /* This is the first use statement. */ // The first non-comment line must be the use line. $lastValidContent = $useToken; for ($i = ($useToken - 1); $i > $opener; $i--) { if ($tokens[$i]['code'] === T_WHITESPACE && ($tokens[($i - 1)]['line'] === $tokens[$i]['line'] || $tokens[($i + 1)]['line'] === $tokens[$i]['line']) ) { continue; } if (isset(Tokens::$commentTokens[$tokens[$i]['code']]) === true) { if ($tokens[$i]['code'] === T_DOC_COMMENT_CLOSE_TAG) { // Skip past the comment. $i = $tokens[$i]['comment_opener']; } $lastValidContent = $i; continue; } break; }//end for if ($tokens[$lastValidContent]['line'] !== ($tokens[$opener]['line'] + 1)) { $error = 'The first trait import statement must be declared on the first non-comment line after the %s opening brace'; $data = [strtolower($tokens[$ooToken]['content'])]; // Figure out if we can fix this error. $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($useToken - 1), ($opener - 1), true); if ($tokens[$prev]['line'] === $tokens[$opener]['line']) { $fix = $phpcsFile->addFixableError($error, $useToken, 'UseAfterBrace', $data); if ($fix === true) { // We know that the USE statements is the first non-comment content // in the class, so we just need to remove blank lines. $phpcsFile->fixer->beginChangeset(); for ($i = ($useToken - 1); $i > $opener; $i--) { if ($tokens[$i]['line'] === $tokens[$opener]['line']) { break; } if ($tokens[$i]['line'] === $tokens[$useToken]['line']) { continue; } if ($tokens[$i]['code'] === T_WHITESPACE && $tokens[($i - 1)]['line'] !== $tokens[$i]['line'] && $tokens[($i + 1)]['line'] !== $tokens[$i]['line'] ) { $phpcsFile->fixer->replaceToken($i, ''); } if (isset(Tokens::$commentTokens[$tokens[$i]['code']]) === true) { if ($tokens[$i]['code'] === T_DOC_COMMENT_CLOSE_TAG) { // Skip past the comment. $i = $tokens[$i]['comment_opener']; } $lastValidContent = $i; } }//end for $phpcsFile->fixer->endChangeset(); }//end if } else { $phpcsFile->addError($error, $useToken, 'UseAfterBrace', $data); }//end if }//end if } else { // Make sure this use statement is not on the same line as the previous one. $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($useToken - 1), null, true); if ($prev !== false && $tokens[$prev]['line'] === $tokens[$useToken]['line']) { $error = 'Each imported trait must be on its own line'; $prevNonWs = $phpcsFile->findPrevious(T_WHITESPACE, ($useToken - 1), null, true); if ($prevNonWs !== $prev) { $phpcsFile->addError($error, $useToken, 'SpacingBeforeImport'); } else { $fix = $phpcsFile->addFixableError($error, $useToken, 'SpacingBeforeImport'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($x = ($useToken - 1); $x > $prev; $x--) { if ($tokens[$x]['line'] === $tokens[$useToken]['line'] ) { // Preserve indent. continue; } $phpcsFile->fixer->replaceToken($x, ''); } $phpcsFile->fixer->addNewline($prev); if ($tokens[$prev]['line'] === $tokens[$useToken]['line']) { if ($tokens[($useToken - 1)]['code'] === T_WHITESPACE) { $phpcsFile->fixer->replaceToken(($useToken - 1), ''); } $padding = str_repeat(' ', ($tokens[$useTokens[0]]['column'] - 1)); $phpcsFile->fixer->addContent($prev, $padding); } $phpcsFile->fixer->endChangeset(); }//end if }//end if }//end if }//end if // Check the formatting of the statement. if (isset($tokens[$useToken]['scope_opener']) === true) { $this->processUseGroup($phpcsFile, $useToken); $end = $tokens[$useToken]['scope_closer']; } else { $this->processUseStatement($phpcsFile, $useToken); $end = $phpcsFile->findNext(T_SEMICOLON, ($useToken + 1)); if ($end === false) { // Syntax error. return; } } if ($usePos === ($numUseTokens - 1)) { /* This is the last use statement. */ $next = $phpcsFile->findNext(T_WHITESPACE, ($end + 1), null, true); if ($next === $tokens[$ooToken]['scope_closer']) { // Last content in the class. $closer = $tokens[$ooToken]['scope_closer']; if ($tokens[$closer]['line'] > ($tokens[$end]['line'] + 1)) { $error = 'There must be no blank line after the last trait import statement at the bottom of a %s'; $data = [strtolower($tokens[$ooToken]['content'])]; $fix = $phpcsFile->addFixableError($error, $end, 'BlankLineAfterLastUse', $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($end + 1); $i < $closer; $i++) { if ($tokens[$i]['line'] === $tokens[$end]['line']) { continue; } if ($tokens[$i]['line'] === $tokens[$closer]['line']) { // Don't remove indents. break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } }//end if } else if ($tokens[$next]['code'] !== T_USE) { // Comments are allowed on the same line as the use statement, so make sure // we don't error for those. for ($next = ($end + 1); $next < $tokens[$ooToken]['scope_closer']; $next++) { if ($tokens[$next]['code'] === T_WHITESPACE) { continue; } if (isset(Tokens::$commentTokens[$tokens[$next]['code']]) === true && $tokens[$next]['line'] === $tokens[$end]['line'] ) { continue; } break; } if ($tokens[$next]['line'] <= ($tokens[$end]['line'] + 1)) { $error = 'There must be a blank line following the last trait import statement'; $fix = $phpcsFile->addFixableError($error, $end, 'NoBlankLineAfterUse'); if ($fix === true) { if ($tokens[$next]['line'] === $tokens[$useToken]['line']) { $phpcsFile->fixer->addContentBefore($next, $phpcsFile->eolChar.$phpcsFile->eolChar); } else { for ($i = ($next - 1); $i > $end; $i--) { if ($tokens[$i]['line'] !== $tokens[$next]['line']) { break; } } $phpcsFile->fixer->addNewlineBefore(($i + 1)); } } } }//end if } else { // Ensure use statements are grouped. $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($end + 1), null, true); if ($next !== $useTokens[($usePos + 1)]) { $error = 'Imported traits must be grouped together'; $phpcsFile->addError($error, $useTokens[($usePos + 1)], 'NotGrouped'); } }//end if }//end foreach return $tokens[$ooToken]['scope_closer']; }//end process() /** * Processes a group use statement. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ protected function processUseGroup(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $opener = $tokens[$stackPtr]['scope_opener']; $closer = $tokens[$stackPtr]['scope_closer']; if ($tokens[$opener]['line'] !== $tokens[$stackPtr]['line']) { $error = 'The opening brace of a trait import statement must be on the same line as the USE keyword'; // Figure out if we can fix this error. $canFix = true; for ($i = ($stackPtr + 1); $i < $opener; $i++) { if ($tokens[$i]['line'] !== $tokens[($i + 1)]['line'] && $tokens[$i]['code'] !== T_WHITESPACE ) { $canFix = false; break; } } if ($canFix === true) { $fix = $phpcsFile->addFixableError($error, $opener, 'OpenBraceNewLine'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($stackPtr + 1); $i < $opener; $i++) { if ($tokens[$i]['line'] !== $tokens[($i + 1)]['line']) { // Everything should have a single space around it. $phpcsFile->fixer->replaceToken($i, ' '); } } $phpcsFile->fixer->endChangeset(); } } else { $phpcsFile->addError($error, $opener, 'OpenBraceNewLine'); } }//end if $error = 'Expected 1 space before opening brace in trait import statement; %s found'; if ($tokens[($opener - 1)]['code'] !== T_WHITESPACE) { $data = ['0']; $fix = $phpcsFile->addFixableError($error, $opener, 'SpaceBeforeOpeningBrace', $data); if ($fix === true) { $phpcsFile->fixer->addContentBefore($opener, ' '); } } else if ($tokens[($opener - 1)]['content'] !== ' ') { $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($opener - 1), null, true); if ($tokens[$prev]['line'] !== $tokens[$opener]['line']) { $found = 'newline'; } else { $found = $tokens[($opener - 1)]['length']; } $data = [$found]; $fix = $phpcsFile->addFixableError($error, $opener, 'SpaceBeforeOpeningBrace', $data); if ($fix === true) { if ($found === 'newline') { $phpcsFile->fixer->beginChangeset(); for ($x = ($opener - 1); $x > $prev; $x--) { $phpcsFile->fixer->replaceToken($x, ''); } $phpcsFile->fixer->addContentBefore($opener, ' '); $phpcsFile->fixer->endChangeset(); } else { $phpcsFile->fixer->replaceToken(($opener - 1), ' '); } } }//end if $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($opener + 1), ($closer - 1), true); if ($next !== false && $tokens[$next]['line'] !== ($tokens[$opener]['line'] + 1)) { $error = 'First trait conflict resolution statement must be on the line after the opening brace'; $nextNonWs = $phpcsFile->findNext(T_WHITESPACE, ($opener + 1), ($closer - 1), true); if ($nextNonWs !== $next) { $phpcsFile->addError($error, $opener, 'SpaceAfterOpeningBrace'); } else { $fix = $phpcsFile->addFixableError($error, $opener, 'SpaceAfterOpeningBrace'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($x = ($opener + 1); $x < $next; $x++) { if ($tokens[$x]['line'] === $tokens[$next]['line']) { // Preserve indent. break; } $phpcsFile->fixer->replaceToken($x, ''); } $phpcsFile->fixer->addNewline($opener); $phpcsFile->fixer->endChangeset(); } } }//end if for ($i = ($stackPtr + 1); $i < $opener; $i++) { if ($tokens[$i]['code'] !== T_COMMA) { continue; } if ($tokens[($i - 1)]['code'] === T_WHITESPACE) { $error = 'Expected no space before comma in trait import statement; %s found'; $data = [$tokens[($i - 1)]['length']]; $fix = $phpcsFile->addFixableError($error, $i, 'SpaceBeforeComma', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($i - 1), ''); } } $error = 'Expected 1 space after comma in trait import statement; %s found'; if ($tokens[($i + 1)]['code'] !== T_WHITESPACE) { $data = ['0']; $fix = $phpcsFile->addFixableError($error, $i, 'SpaceAfterComma', $data); if ($fix === true) { $phpcsFile->fixer->addContent($i, ' '); } } else if ($tokens[($i + 1)]['content'] !== ' ') { $next = $phpcsFile->findNext(T_WHITESPACE, ($i + 1), $opener, true); if ($tokens[$next]['line'] !== $tokens[$i]['line']) { $found = 'newline'; } else { $found = $tokens[($i + 1)]['length']; } $data = [$found]; $fix = $phpcsFile->addFixableError($error, $i, 'SpaceAfterComma', $data); if ($fix === true) { if ($found === 'newline') { $phpcsFile->fixer->beginChangeset(); for ($x = ($i + 1); $x < $next; $x++) { $phpcsFile->fixer->replaceToken($x, ''); } $phpcsFile->fixer->addContent($i, ' '); $phpcsFile->fixer->endChangeset(); } else { $phpcsFile->fixer->replaceToken(($i + 1), ' '); } } }//end if }//end for for ($i = ($opener + 1); $i < $closer; $i++) { if ($tokens[$i]['code'] === T_INSTEADOF) { $error = 'Expected 1 space before INSTEADOF in trait import statement; %s found'; if ($tokens[($i - 1)]['code'] !== T_WHITESPACE) { $data = ['0']; $fix = $phpcsFile->addFixableError($error, $i, 'SpaceBeforeInsteadof', $data); if ($fix === true) { $phpcsFile->fixer->addContentBefore($i, ' '); } } else if ($tokens[($i - 1)]['content'] !== ' ') { $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($i - 1), $opener, true); if ($tokens[$prev]['line'] !== $tokens[$i]['line']) { $found = 'newline'; } else { $found = $tokens[($i - 1)]['length']; } $data = [$found]; $prevNonWs = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($i - 1), $opener, true); if ($prevNonWs !== $prev) { $phpcsFile->addError($error, $i, 'SpaceBeforeInsteadof', $data); } else { $fix = $phpcsFile->addFixableError($error, $i, 'SpaceBeforeInsteadof', $data); if ($fix === true) { if ($found === 'newline') { $phpcsFile->fixer->beginChangeset(); for ($x = ($i - 1); $x > $prev; $x--) { $phpcsFile->fixer->replaceToken($x, ''); } $phpcsFile->fixer->addContentBefore($i, ' '); $phpcsFile->fixer->endChangeset(); } else { $phpcsFile->fixer->replaceToken(($i - 1), ' '); } } } }//end if $error = 'Expected 1 space after INSTEADOF in trait import statement; %s found'; if ($tokens[($i + 1)]['code'] !== T_WHITESPACE) { $data = ['0']; $fix = $phpcsFile->addFixableError($error, $i, 'SpaceAfterInsteadof', $data); if ($fix === true) { $phpcsFile->fixer->addContent($i, ' '); } } else if ($tokens[($i + 1)]['content'] !== ' ') { $next = $phpcsFile->findNext(T_WHITESPACE, ($i + 1), $closer, true); if ($tokens[$next]['line'] !== $tokens[$i]['line']) { $found = 'newline'; } else { $found = $tokens[($i + 1)]['length']; } $data = [$found]; $nextNonWs = $phpcsFile->findNext(Tokens::$emptyTokens, ($i + 1), $closer, true); if ($nextNonWs !== $next) { $phpcsFile->addError($error, $i, 'SpaceAfterInsteadof', $data); } else { $fix = $phpcsFile->addFixableError($error, $i, 'SpaceAfterInsteadof', $data); if ($fix === true) { if ($found === 'newline') { $phpcsFile->fixer->beginChangeset(); for ($x = ($i + 1); $x < $next; $x++) { $phpcsFile->fixer->replaceToken($x, ''); } $phpcsFile->fixer->addContent($i, ' '); $phpcsFile->fixer->endChangeset(); } else { $phpcsFile->fixer->replaceToken(($i + 1), ' '); } } } }//end if }//end if if ($tokens[$i]['code'] === T_AS) { $error = 'Expected 1 space before AS in trait import statement; %s found'; if ($tokens[($i - 1)]['code'] !== T_WHITESPACE) { $data = ['0']; $fix = $phpcsFile->addFixableError($error, $i, 'SpaceBeforeAs', $data); if ($fix === true) { $phpcsFile->fixer->addContentBefore($i, ' '); } } else if ($tokens[($i - 1)]['content'] !== ' ') { $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($i - 1), $opener, true); if ($tokens[$prev]['line'] !== $tokens[$i]['line']) { $found = 'newline'; } else { $found = $tokens[($i - 1)]['length']; } $data = [$found]; $prevNonWs = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($i - 1), $opener, true); if ($prevNonWs !== $prev) { $phpcsFile->addError($error, $i, 'SpaceBeforeAs', $data); } else { $fix = $phpcsFile->addFixableError($error, $i, 'SpaceBeforeAs', $data); if ($fix === true) { if ($found === 'newline') { $phpcsFile->fixer->beginChangeset(); for ($x = ($i - 1); $x > $prev; $x--) { $phpcsFile->fixer->replaceToken($x, ''); } $phpcsFile->fixer->addContentBefore($i, ' '); $phpcsFile->fixer->endChangeset(); } else { $phpcsFile->fixer->replaceToken(($i - 1), ' '); } } } }//end if $error = 'Expected 1 space after AS in trait import statement; %s found'; if ($tokens[($i + 1)]['code'] !== T_WHITESPACE) { $data = ['0']; $fix = $phpcsFile->addFixableError($error, $i, 'SpaceAfterAs', $data); if ($fix === true) { $phpcsFile->fixer->addContent($i, ' '); } } else if ($tokens[($i + 1)]['content'] !== ' ') { $next = $phpcsFile->findNext(T_WHITESPACE, ($i + 1), $closer, true); if ($tokens[$next]['line'] !== $tokens[$i]['line']) { $found = 'newline'; } else { $found = $tokens[($i + 1)]['length']; } $data = [$found]; $nextNonWs = $phpcsFile->findNext(Tokens::$emptyTokens, ($i + 1), $closer, true); if ($nextNonWs !== $next) { $phpcsFile->addError($error, $i, 'SpaceAfterAs', $data); } else { $fix = $phpcsFile->addFixableError($error, $i, 'SpaceAfterAs', $data); if ($fix === true) { if ($found === 'newline') { $phpcsFile->fixer->beginChangeset(); for ($x = ($i + 1); $x < $next; $x++) { $phpcsFile->fixer->replaceToken($x, ''); } $phpcsFile->fixer->addContent($i, ' '); $phpcsFile->fixer->endChangeset(); } else { $phpcsFile->fixer->replaceToken(($i + 1), ' '); } } } }//end if }//end if if ($tokens[$i]['code'] === T_SEMICOLON) { if ($tokens[($i - 1)]['code'] === T_WHITESPACE) { $error = 'Expected no space before semicolon in trait import statement; %s found'; $data = [$tokens[($i - 1)]['length']]; $fix = $phpcsFile->addFixableError($error, $i, 'SpaceBeforeSemicolon', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($i - 1), ''); } } $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($i + 1), ($closer - 1), true); if ($next !== false && $tokens[$next]['line'] === $tokens[$i]['line']) { $error = 'Each trait conflict resolution statement must be on a line by itself'; $nextNonWs = $phpcsFile->findNext(T_WHITESPACE, ($i + 1), ($closer - 1), true); if ($nextNonWs !== $next) { $phpcsFile->addError($error, $i, 'ConflictSameLine'); } else { $fix = $phpcsFile->addFixableError($error, $i, 'ConflictSameLine'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); if ($tokens[($i + 1)]['code'] === T_WHITESPACE) { $phpcsFile->fixer->replaceToken(($i + 1), ''); } $phpcsFile->fixer->addNewline($i); $phpcsFile->fixer->endChangeset(); } } } }//end if }//end for $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($closer - 1), ($opener + 1), true); if ($prev !== false && $tokens[$prev]['line'] !== ($tokens[$closer]['line'] - 1)) { $error = 'Closing brace must be on the line after the last trait conflict resolution statement'; $prevNonWs = $phpcsFile->findPrevious(T_WHITESPACE, ($closer - 1), ($opener + 1), true); if ($prevNonWs !== $prev) { $phpcsFile->addError($error, $closer, 'SpaceBeforeClosingBrace'); } else { $fix = $phpcsFile->addFixableError($error, $closer, 'SpaceBeforeClosingBrace'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($x = ($closer - 1); $x > $prev; $x--) { if ($tokens[$x]['line'] === $tokens[$closer]['line']) { // Preserve indent. continue; } $phpcsFile->fixer->replaceToken($x, ''); } $phpcsFile->fixer->addNewline($prev); $phpcsFile->fixer->endChangeset(); } } }//end if }//end processUseGroup() /** * Processes a single use statement. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ protected function processUseStatement(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $error = 'Expected 1 space after USE in trait import statement; %s found'; if ($tokens[($stackPtr + 1)]['code'] !== T_WHITESPACE) { $data = ['0']; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceAfterAs', $data); if ($fix === true) { $phpcsFile->fixer->addContent($stackPtr, ' '); } } else if ($tokens[($stackPtr + 1)]['content'] !== ' ') { $next = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($tokens[$next]['line'] !== $tokens[$stackPtr]['line']) { $found = 'newline'; } else { $found = $tokens[($stackPtr + 1)]['length']; } $data = [$found]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceAfterAs', $data); if ($fix === true) { if ($found === 'newline') { $phpcsFile->fixer->beginChangeset(); for ($x = ($stackPtr + 1); $x < $next; $x++) { $phpcsFile->fixer->replaceToken($x, ''); } $phpcsFile->fixer->addContent($stackPtr, ' '); $phpcsFile->fixer->endChangeset(); } else { $phpcsFile->fixer->replaceToken(($stackPtr + 1), ' '); } } }//end if $next = $phpcsFile->findNext([T_COMMA, T_SEMICOLON], ($stackPtr + 1)); if ($next !== false && $tokens[$next]['code'] === T_COMMA) { $error = 'Each imported trait must have its own "use" import statement'; $fix = $phpcsFile->addFixableError($error, $next, 'MultipleImport'); if ($fix === true) { $padding = str_repeat(' ', ($tokens[$stackPtr]['column'] - 1)); $phpcsFile->fixer->replaceToken($next, ';'.$phpcsFile->eolChar.$padding.'use '); } } }//end processUseStatement() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/Classes/AnonClassDeclarationUnitTest.inc0000644000076500000240000000226213614652361030560 0ustar gsherwoodstaffbar( new class implements Bar { // ... }, ); foo(new class { }); PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/Classes/AnonClassDeclarationUnitTest.inc.fixed0000644000076500000240000000226113614652361031655 0ustar gsherwoodstaffbar( new class implements Bar { // ... }, ); foo(new class { }); PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/Classes/AnonClassDeclarationUnitTest.php0000644000076500000240000000320013614652361030567 0ustar gsherwoodstaff * @copyright 2006-2019 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Tests\Classes; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class AnonClassDeclarationUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 28 => 3, 30 => 1, 31 => 4, 32 => 1, 33 => 1, 34 => 1, 35 => 2, 36 => 1, 37 => 3, 39 => 1, 40 => 1, 43 => 3, 44 => 4, 45 => 1, 48 => 1, 52 => 3, 53 => 1, 54 => 1, 55 => 1, 56 => 2, 63 => 1, 75 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/Classes/ClassInstantiationUnitTest.inc0000644000076500000240000000136513614652361030346 0ustar gsherwoodstaffbar(); echo (new Foo)->bar(); echo (new Foo((new Bar)->getBaz()))->bar(); $foo = (new Foo)::$bar; echo (new Foo((new Bar//comment )->getBaz(new Baz /* comment */)))->bar(); $foo = new $bar['a'](); $foo = new $bar['a']['b'](); $foo = new $bar['a'][$baz['a']['b']]['b'](); $foo = new $bar['a'] [$baz['a']/* comment */ ['b']]['b']; $a = new self::$transport[$cap_string]; $renderer = new $this->inline_diff_renderer; $a = new ${$varHoldingClassName}; PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/Classes/ClassInstantiationUnitTest.inc.fixed0000644000076500000240000000142313614652361031437 0ustar gsherwoodstaffbar(); echo (new Foo())->bar(); echo (new Foo((new Bar())->getBaz()))->bar(); $foo = (new Foo())::$bar; echo (new Foo((new Bar()//comment )->getBaz(new Baz() /* comment */)))->bar(); $foo = new $bar['a'](); $foo = new $bar['a']['b'](); $foo = new $bar['a'][$baz['a']['b']]['b'](); $foo = new $bar['a'] [$baz['a']/* comment */ ['b']]['b'](); $a = new self::$transport[$cap_string](); $renderer = new $this->inline_diff_renderer(); $a = new ${$varHoldingClassName}(); PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/Classes/ClassInstantiationUnitTest.php0000644000076500000240000000275113614652361030364 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Tests\Classes; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ClassInstantiationUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 3 => 1, 4 => 1, 9 => 1, 11 => 1, 14 => 1, 16 => 1, 20 => 1, 21 => 1, 22 => 1, 24 => 1, 25 => 1, 30 => 1, 32 => 1, 33 => 1, 34 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/Classes/ClosingBraceUnitTest.inc0000644000076500000240000000102613614652361027061 0ustar gsherwoodstaffbar( $arg1, function ($arg2) use ($var1) { // body }, $arg3 ); $instance = new class extends \Foo implements \HandleableInterface { // Class content }; $app->get('/hello/{name}', function ($name) use ($app) { return 'Hello ' . $app->escape($name); }); PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/Classes/ClosingBraceUnitTest.php0000644000076500000240000000241313614652361027100 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Tests\Classes; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ClosingBraceUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 13 => 1, 14 => 1, 19 => 1, 24 => 1, 31 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class ././@LongLink0000000000000000000000000000014600000000000007756 Lustar PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/ControlStructures/BooleanOperatorPlacementUnitTest.incPHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/ControlStructures/BooleanOperatorPlacementUnitTest.i0000644000076500000240000000271513614652361033266 0ustar gsherwoodstaff 0 && $n < 10) || ($n > 10 && $n < 20) || ($n > 20 && $n < 30) ) { return $n; } if ( ( $expr1 && $expr2 && $expr3 && $expr4 && $expr5 && $expr6 ) || ($n > 100 && $n < 200) || ($n > 200 && $n < 300) ) { return $n; } // phpcs:set PSR12.ControlStructures.BooleanOperatorPlacement allowOnly first if ( $expr1 && $expr2 && ($expr3 || $expr4) && $expr5 ) { // if body } elseif ( $expr1 && ($expr3 || $expr4) && $expr5 ) { // elseif body } elseif ( $expr1 && ($expr3 || $expr4) && $expr5 ) { // elseif body } // phpcs:set PSR12.ControlStructures.BooleanOperatorPlacement allowOnly last if ( $expr1 && $expr2 && ($expr3 || $expr4) && $expr5 ) { // if body } elseif ( $expr1 && ($expr3 || $expr4) && $expr5 ) { // elseif body } elseif ( $expr1 && ($expr3 || $expr4) && $expr5 ) { // elseif body } ././@LongLink0000000000000000000000000000015400000000000007755 Lustar PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/ControlStructures/BooleanOperatorPlacementUnitTest.inc.fixedPHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/ControlStructures/BooleanOperatorPlacementUnitTest.i0000644000076500000240000000276513614652361033273 0ustar gsherwoodstaff 0 && $n < 10) || ($n > 10 && $n < 20) || ($n > 20 && $n < 30) ) { return $n; } if ( ( $expr1 && $expr2 && $expr3 && $expr4 && $expr5 && $expr6 ) || ($n > 100 && $n < 200) || ($n > 200 && $n < 300) ) { return $n; } // phpcs:set PSR12.ControlStructures.BooleanOperatorPlacement allowOnly first if ( $expr1 && $expr2 && ($expr3 || $expr4) && $expr5 ) { // if body } elseif ( $expr1 && ($expr3 || $expr4) && $expr5 ) { // elseif body } elseif ( $expr1 && ($expr3 || $expr4) && $expr5 ) { // elseif body } // phpcs:set PSR12.ControlStructures.BooleanOperatorPlacement allowOnly last if ( $expr1 && $expr2 && ($expr3 || $expr4) && $expr5 ) { // if body } elseif ( $expr1 && ($expr3 || $expr4) && $expr5 ) { // elseif body } elseif ( $expr1 && ($expr3 || $expr4) && $expr5 ) { // elseif body } ././@LongLink0000000000000000000000000000014600000000000007756 Lustar PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/ControlStructures/BooleanOperatorPlacementUnitTest.phpPHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/ControlStructures/BooleanOperatorPlacementUnitTest.p0000644000076500000240000000261213614652361033271 0ustar gsherwoodstaff * @copyright 2006-2019 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Tests\ControlStructures; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class BooleanOperatorPlacementUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 10 => 1, 16 => 1, 28 => 1, 34 => 1, 75 => 1, 81 => 1, 90 => 1, 98 => 1, 104 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class ././@LongLink0000000000000000000000000000014500000000000007755 Lustar PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/ControlStructures/ControlStructureSpacingUnitTest.incPHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/ControlStructures/ControlStructureSpacingUnitTest.in0000644000076500000240000000137113614652361033363 0ustar gsherwoodstaff $foo /* * A multi-line comment. */ && $foo === true ) { break; } ././@LongLink0000000000000000000000000000015300000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/ControlStructures/ControlStructureSpacingUnitTest.inc.fixedPHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/ControlStructures/ControlStructureSpacingUnitTest.in0000644000076500000240000000142213614652361033360 0ustar gsherwoodstaff $foo /* * A multi-line comment. */ && $foo === true ) { break; } ././@LongLink0000000000000000000000000000014500000000000007755 Lustar PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/ControlStructures/ControlStructureSpacingUnitTest.phpPHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/ControlStructures/ControlStructureSpacingUnitTest.ph0000644000076500000240000000277513614652361033375 0ustar gsherwoodstaff * @copyright 2006-2019 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Tests\ControlStructures; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ControlStructureSpacingUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 2 => 2, 16 => 1, 17 => 1, 18 => 1, 22 => 1, 23 => 1, 32 => 1, 33 => 1, 34 => 1, 37 => 1, 38 => 1, 39 => 1, 48 => 2, 58 => 1, 59 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/Files/DeclareStatementUnitTest.inc0000644000076500000240000000154013614652361027420 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Tests\Files; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class DeclareStatementUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 2 => 1, 3 => 1, 4 => 1, 5 => 2, 6 => 1, 7 => 1, 9 => 2, 10 => 1, 11 => 3, 12 => 2, 13 => 1, 14 => 2, 16 => 3, 19 => 3, 22 => 1, 24 => 1, 26 => 3, 28 => 3, 34 => 2, 43 => 1, 46 => 1, 47 => 1, 49 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/Files/FileHeaderUnitTest.1.inc0000644000076500000240000000123013614652361026317 0ustar gsherwoodstaff

    Demo

    * @copyright 2006-2019 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Tests\Files; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class FileHeaderUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='') { switch ($testFile) { case 'FileHeaderUnitTest.2.inc': return [ 1 => 1, 6 => 1, 7 => 1, 18 => 1, 20 => 1, 24 => 1, ]; case 'FileHeaderUnitTest.3.inc': return [ 9 => 1, 18 => 1, ]; case 'FileHeaderUnitTest.4.inc': return [ 1 => 1, 2 => 1, 3 => 1, 7 => 1, ]; case 'FileHeaderUnitTest.5.inc': return [4 => 1]; case 'FileHeaderUnitTest.7.inc': case 'FileHeaderUnitTest.10.inc': case 'FileHeaderUnitTest.11.inc': return [1 => 1]; case 'FileHeaderUnitTest.12.inc': return [4 => 2]; default: return []; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/Files/ImportStatementUnitTest.inc0000644000076500000240000000075413614652361027341 0ustar gsherwoodstaff * @copyright 2006-2019 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Tests\Files; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ImportStatementUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 2 => 1, 4 => 1, 7 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/Files/OpenTagUnitTest.1.inc0000644000076500000240000000002213614652361025662 0ustar gsherwoodstaff hi PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/Files/OpenTagUnitTest.4.inc0000644000076500000240000000002213614652361025665 0ustar gsherwoodstaff * @copyright 2006-2019 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Tests\Files; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class OpenTagUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='') { switch ($testFile) { case 'OpenTagUnitTest.2.inc': return [1 => 1]; default: return []; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/Functions/NullableTypeDeclarationUnitTest.inc0000644000076500000240000000403213614652361031647 0ustar gsherwoodstaff * @copyright 2006-2018 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Tests\Functions; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class NullableTypeDeclarationUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ protected function getErrorList() { return [ 23 => 1, 24 => 1, 25 => 1, 30 => 1, 31 => 1, 32 => 1, 43 => 2, 48 => 1, 50 => 1, 51 => 1, 53 => 1, 57 => 2, 58 => 2, 59 => 2, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ protected function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/Functions/ReturnTypeDeclarationUnitTest.inc0000644000076500000240000000215513614652361031374 0ustar gsherwoodstaff $arg; PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/Functions/ReturnTypeDeclarationUnitTest.inc.fixed0000644000076500000240000000215013614652361032465 0ustar gsherwoodstaff $arg; PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/Functions/ReturnTypeDeclarationUnitTest.php0000644000076500000240000000267013614652361031414 0ustar gsherwoodstaff * @copyright 2006-2018 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Tests\Functions; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ReturnTypeDeclarationUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ protected function getErrorList() { return [ 27 => 1, 28 => 1, 35 => 2, 41 => 2, 48 => 2, 52 => 1, 55 => 1, 56 => 1, 59 => 1, 60 => 1, 62 => 1, 64 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ protected function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/Keywords/ShortFormTypeKeywordsUnitTest.inc0000644000076500000240000000047113614652361031260 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Tests\Keywords; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ShortFormTypeKeywordsUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 3 => 1, 5 => 1, 7 => 1, 13 => 1, 14 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/Namespaces/CompoundNamespaceDepthUnitTest.inc0000644000076500000240000000117713614652361031605 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Tests\Namespaces; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class CompoundNamespaceDepthUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 10 => 1, 18 => 1, 21 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/Operators/OperatorSpacingUnitTest.inc0000644000076500000240000000160013614652361030205 0ustar gsherwoodstaff $b) { $variable =$foo ? 'foo' :'bar'; $variable.='text'.'text'; } $foo+= $a&$b; $foo = $a|$b; $foo =$a^$b; $foo = ~$a; $foo *=$a<<$b; $foo = $a>>$b; function foo(&$a,& $b) {} $foo = $a and$b; $foo = $a or $b; $foo = $a xor$b; $foo = !$a; $foo = $a&&$b; $foo = $a||$b; $foo = $a instanceof Foo; $foo = $a instanceof$b; $foo .= 'hi' .= 'there'; $foo .= 'hi' .= 'there'; $foo .= 'hi' // comment .= 'there'; $foo/*comment*/=/*comment*/$a/*comment*/and/*comment*/$b; $foo .=//comment 'string' .=/*comment*/ 'string'; $foo = $foo ?: 'bar'; $foo = $foo?:'bar'; try { } catch (ExceptionType1|ExceptionType2 $e) { } if (strpos($tokenContent, 'b"') === 0 && substr($tokenContent, -1) === '"') {} $oldConstructorPos = +1; return -$content; function name($a = -1) {} $a =& $ref; $a = [ 'a' => &$something ]; PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/Operators/OperatorSpacingUnitTest.inc.fixed0000644000076500000240000000165013614652361031310 0ustar gsherwoodstaff $b) { $variable = $foo ? 'foo' : 'bar'; $variable .= 'text' . 'text'; } $foo += $a & $b; $foo = $a | $b; $foo = $a ^ $b; $foo = ~$a; $foo *= $a << $b; $foo = $a >> $b; function foo(&$a,& $b) {} $foo = $a and $b; $foo = $a or $b; $foo = $a xor $b; $foo = !$a; $foo = $a && $b; $foo = $a || $b; $foo = $a instanceof Foo; $foo = $a instanceof $b; $foo .= 'hi' .= 'there'; $foo .= 'hi' .= 'there'; $foo .= 'hi' // comment .= 'there'; $foo/*comment*/ = /*comment*/$a/*comment*/ and /*comment*/$b; $foo .= //comment 'string' .= /*comment*/ 'string'; $foo = $foo ?: 'bar'; $foo = $foo ?: 'bar'; try { } catch (ExceptionType1 | ExceptionType2 $e) { } if (strpos($tokenContent, 'b"') === 0 && substr($tokenContent, -1) === '"') {} $oldConstructorPos = +1; return -$content; function name($a = -1) {} $a =& $ref; $a = [ 'a' => &$something ]; PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/Operators/OperatorSpacingUnitTest.php0000644000076500000240000000311613614652361030227 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Tests\Operators; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class OperatorSpacingUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 2 => 1, 3 => 2, 4 => 1, 5 => 2, 6 => 4, 9 => 3, 10 => 2, 11 => 3, 13 => 3, 14 => 2, 18 => 1, 20 => 1, 22 => 2, 23 => 2, 26 => 1, 37 => 4, 39 => 1, 40 => 1, 44 => 2, 47 => 2, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/Properties/ConstantVisibilityUnitTest.inc0000644000076500000240000000016113614652361031125 0ustar gsherwoodstaff * @copyright 2006-2019 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Tests\Properties; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ConstantVisibilityUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return []; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return [4 => 1]; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/Tests/Traits/UseDeclarationUnitTest.inc0000644000076500000240000000513313614652361027304 0ustar gsherwoodstaff * @copyright 2006-2019 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR12\Tests\Traits; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class UseDeclarationUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 15 => 1, 29 => 2, 30 => 1, 42 => 1, 57 => 3, 59 => 3, 61 => 1, 63 => 5, 65 => 1, 71 => 1, 73 => 2, 76 => 1, 86 => 2, 103 => 1, 112 => 1, 122 => 1, 132 => 1, 157 => 1, 165 => 1, 170 => 1, 208 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR12/ruleset.xml0000644000076500000240000005245213614652361022052 0ustar gsherwoodstaff The PSR-12 coding standard. 0 0 0 error Method name "%s" must not be prefixed with an underscore to indicate visibility 0 0 0 0 0 0 0 PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Docs/Classes/ClassDeclarationStandard.xml0000644000076500000240000000170613614652361027463 0ustar gsherwoodstaff class Foo { } ]]> class Foo { } ]]> PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Docs/Classes/PropertyDeclarationStandard.xml0000644000076500000240000000363313614652361030243 0ustar gsherwoodstaff bar; } ]]> _bar; } ]]> private $bar; } ]]> var $bar; } ]]> $bar, $baz; } ]]> static $bar; private $baz; } ]]> static protected $bar; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Docs/ControlStructures/ControlStructureSpacingStandard.xml0000644000076500000240000000110513614652361033236 0ustar gsherwoodstaff $foo) { $var = 1; } ]]> $foo ) { $var = 1; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Docs/ControlStructures/ElseIfDeclarationStandard.xml0000644000076500000240000000110513614652361031705 0ustar gsherwoodstaff elseif ($bar) { $var = 2; } ]]> else if ($bar) { $var = 2; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Docs/ControlStructures/SwitchDeclarationStandard.xml0000644000076500000240000000472113614652361032006 0ustar gsherwoodstaff case 'bar': break; } ]]> case 'bar': break; } ]]> 'bar': break; } ]]> 'bar': break; } ]]> : break; default: break; } ]]> : break; default : break; } ]]> break; } ]]> break; } ]]> // no break default: break; } ]]> : break; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Docs/Files/EndFileNewlineStandard.xml0000644000076500000240000000024213614652361026537 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Docs/Methods/MethodDeclarationStandard.xml0000644000076500000240000000225113614652361027640 0ustar gsherwoodstaff bar() { } } ]]> _bar() { } } ]]> final public static function bar() { } } ]]> static public final function bar() { } } ]]> PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Docs/Namespaces/NamespaceDeclarationStandard.xml0000644000076500000240000000104313614652361030766 0ustar gsherwoodstaff use \Baz; ]]> PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Docs/Namespaces/UseDeclarationStandard.xml0000644000076500000240000000243613614652361027635 0ustar gsherwoodstaff \Foo, \Bar; ]]> class Baz { } ]]> PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Sniffs/Classes/ClassDeclarationSniff.php0000644000076500000240000005451213614652361027322 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR2\Sniffs\Classes; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Standards\PEAR\Sniffs\Classes\ClassDeclarationSniff as PEARClassDeclarationSniff; use PHP_CodeSniffer\Util\Tokens; class ClassDeclarationSniff extends PEARClassDeclarationSniff { /** * The number of spaces code should be indented. * * @var integer */ public $indent = 4; /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { // We want all the errors from the PEAR standard, plus some of our own. parent::process($phpcsFile, $stackPtr); // Just in case. $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['scope_opener']) === false) { return; } $this->processOpen($phpcsFile, $stackPtr); $this->processClose($phpcsFile, $stackPtr); }//end process() /** * Processes the opening section of a class declaration. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function processOpen(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $stackPtrType = strtolower($tokens[$stackPtr]['content']); // Check alignment of the keyword and braces. if ($tokens[($stackPtr - 1)]['code'] === T_WHITESPACE) { $prevContent = $tokens[($stackPtr - 1)]['content']; if ($prevContent !== $phpcsFile->eolChar) { $blankSpace = substr($prevContent, strpos($prevContent, $phpcsFile->eolChar)); $spaces = strlen($blankSpace); if (in_array($tokens[($stackPtr - 2)]['code'], [T_ABSTRACT, T_FINAL], true) === true && $spaces !== 1 ) { $prevContent = strtolower($tokens[($stackPtr - 2)]['content']); $error = 'Expected 1 space between %s and %s keywords; %s found'; $data = [ $prevContent, $stackPtrType, $spaces, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceBeforeKeyword', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($stackPtr - 1), ' '); } } } else if ($tokens[($stackPtr - 2)]['code'] === T_ABSTRACT || $tokens[($stackPtr - 2)]['code'] === T_FINAL ) { $prevContent = strtolower($tokens[($stackPtr - 2)]['content']); $error = 'Expected 1 space between %s and %s keywords; newline found'; $data = [ $prevContent, $stackPtrType, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NewlineBeforeKeyword', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($stackPtr - 1), ' '); } }//end if }//end if // We'll need the indent of the class/interface declaration for later. $classIndent = 0; for ($i = ($stackPtr - 1); $i > 0; $i--) { if ($tokens[$i]['line'] === $tokens[$stackPtr]['line']) { continue; } // We changed lines. if ($tokens[($i + 1)]['code'] === T_WHITESPACE) { $classIndent = $tokens[($i + 1)]['length']; } break; } $className = null; $checkSpacing = true; if ($tokens[$stackPtr]['code'] !== T_ANON_CLASS) { $className = $phpcsFile->findNext(T_STRING, $stackPtr); } else { // Ignore the spacing check if this is a simple anon class. $next = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($next === $tokens[$stackPtr]['scope_opener'] && $tokens[$next]['line'] > $tokens[$stackPtr]['line'] ) { $checkSpacing = false; } } if ($checkSpacing === true) { // Spacing of the keyword. if ($tokens[($stackPtr + 1)]['code'] !== T_WHITESPACE) { $gap = 0; } else if ($tokens[($stackPtr + 2)]['line'] !== $tokens[$stackPtr]['line']) { $gap = 'newline'; } else { $gap = $tokens[($stackPtr + 1)]['length']; } if ($gap !== 1) { $error = 'Expected 1 space after %s keyword; %s found'; $data = [ $stackPtrType, $gap, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceAfterKeyword', $data); if ($fix === true) { if ($gap === 0) { $phpcsFile->fixer->addContent($stackPtr, ' '); } else { $phpcsFile->fixer->replaceToken(($stackPtr + 1), ' '); } } } }//end if // Check after the class/interface name. if ($className !== null && $tokens[($className + 2)]['line'] === $tokens[$className]['line'] ) { $gap = $tokens[($className + 1)]['content']; if (strlen($gap) !== 1) { $found = strlen($gap); $error = 'Expected 1 space after %s name; %s found'; $data = [ $stackPtrType, $found, ]; $fix = $phpcsFile->addFixableError($error, $className, 'SpaceAfterName', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($className + 1), ' '); } } } $openingBrace = $tokens[$stackPtr]['scope_opener']; // Check positions of the extends and implements keywords. $compareToken = $stackPtr; $compareType = 'name'; if ($tokens[$stackPtr]['code'] === T_ANON_CLASS) { if (isset($tokens[$stackPtr]['parenthesis_opener']) === true) { $compareToken = $tokens[$stackPtr]['parenthesis_closer']; $compareType = 'closing parenthesis'; } else { $compareType = 'keyword'; } } foreach (['extends', 'implements'] as $keywordType) { $keyword = $phpcsFile->findNext(constant('T_'.strtoupper($keywordType)), ($compareToken + 1), $openingBrace); if ($keyword !== false) { if ($tokens[$keyword]['line'] !== $tokens[$compareToken]['line']) { $error = 'The '.$keywordType.' keyword must be on the same line as the %s '.$compareType; $data = [$stackPtrType]; $fix = $phpcsFile->addFixableError($error, $keyword, ucfirst($keywordType).'Line', $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $comments = []; for ($i = ($compareToken + 1); $i < $keyword; ++$i) { if ($tokens[$i]['code'] === T_COMMENT) { $comments[] = trim($tokens[$i]['content']); } if ($tokens[$i]['code'] === T_WHITESPACE || $tokens[$i]['code'] === T_COMMENT ) { $phpcsFile->fixer->replaceToken($i, ' '); } } $phpcsFile->fixer->addContent($compareToken, ' '); if (empty($comments) === false) { $i = $keyword; while ($tokens[($i + 1)]['line'] === $tokens[$keyword]['line']) { ++$i; } $phpcsFile->fixer->addContentBefore($i, ' '.implode(' ', $comments)); } $phpcsFile->fixer->endChangeset(); }//end if } else { // Check the whitespace before. Whitespace after is checked // later by looking at the whitespace before the first class name // in the list. $gap = $tokens[($keyword - 1)]['length']; if ($gap !== 1) { $error = 'Expected 1 space before '.$keywordType.' keyword; %s found'; $data = [$gap]; $fix = $phpcsFile->addFixableError($error, $keyword, 'SpaceBefore'.ucfirst($keywordType), $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($keyword - 1), ' '); } } }//end if }//end if }//end foreach // Check each of the extends/implements class names. If the extends/implements // keyword is the last content on the line, it means we need to check for // the multi-line format, so we do not include the class names // from the extends/implements list in the following check. // Note that classes can only extend one other class, so they can't use a // multi-line extends format, whereas an interface can extend multiple // other interfaces, and so uses a multi-line extends format. if ($tokens[$stackPtr]['code'] === T_INTERFACE) { $keywordTokenType = T_EXTENDS; } else { $keywordTokenType = T_IMPLEMENTS; } $implements = $phpcsFile->findNext($keywordTokenType, ($stackPtr + 1), $openingBrace); $multiLineImplements = false; if ($implements !== false) { $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($openingBrace - 1), $implements, true); if ($tokens[$prev]['line'] !== $tokens[$implements]['line']) { $multiLineImplements = true; } } $find = [ T_STRING, $keywordTokenType, ]; if ($className !== null) { $start = $className; } else if (isset($tokens[$stackPtr]['parenthesis_closer']) === true) { $start = $tokens[$stackPtr]['parenthesis_closer']; } else { $start = $stackPtr; } $classNames = []; $nextClass = $phpcsFile->findNext($find, ($start + 2), ($openingBrace - 1)); while ($nextClass !== false) { $classNames[] = $nextClass; $nextClass = $phpcsFile->findNext($find, ($nextClass + 1), ($openingBrace - 1)); } $classCount = count($classNames); $checkingImplements = false; $implementsToken = null; foreach ($classNames as $n => $className) { if ($tokens[$className]['code'] === $keywordTokenType) { $checkingImplements = true; $implementsToken = $className; continue; } if ($checkingImplements === true && $multiLineImplements === true && ($tokens[($className - 1)]['code'] !== T_NS_SEPARATOR || $tokens[($className - 2)]['code'] !== T_STRING) ) { $prev = $phpcsFile->findPrevious( [ T_NS_SEPARATOR, T_WHITESPACE, ], ($className - 1), $implements, true ); if ($prev === $implementsToken && $tokens[$className]['line'] !== ($tokens[$prev]['line'] + 1)) { if ($keywordTokenType === T_EXTENDS) { $error = 'The first item in a multi-line extends list must be on the line following the extends keyword'; $fix = $phpcsFile->addFixableError($error, $className, 'FirstExtendsInterfaceSameLine'); } else { $error = 'The first item in a multi-line implements list must be on the line following the implements keyword'; $fix = $phpcsFile->addFixableError($error, $className, 'FirstInterfaceSameLine'); } if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($prev + 1); $i < $className; $i++) { if ($tokens[$i]['code'] !== T_WHITESPACE) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->addNewline($prev); $phpcsFile->fixer->endChangeset(); } } else if ($tokens[$prev]['line'] !== ($tokens[$className]['line'] - 1)) { if ($keywordTokenType === T_EXTENDS) { $error = 'Only one interface may be specified per line in a multi-line extends declaration'; $fix = $phpcsFile->addFixableError($error, $className, 'ExtendsInterfaceSameLine'); } else { $error = 'Only one interface may be specified per line in a multi-line implements declaration'; $fix = $phpcsFile->addFixableError($error, $className, 'InterfaceSameLine'); } if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($prev + 1); $i < $className; $i++) { if ($tokens[$i]['code'] !== T_WHITESPACE) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->addNewline($prev); $phpcsFile->fixer->endChangeset(); } } else { $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($className - 1), $implements); if ($tokens[$prev]['line'] !== $tokens[$className]['line']) { $found = 0; } else { $found = $tokens[$prev]['length']; } $expected = ($classIndent + $this->indent); if ($found !== $expected) { $error = 'Expected %s spaces before interface name; %s found'; $data = [ $expected, $found, ]; $fix = $phpcsFile->addFixableError($error, $className, 'InterfaceWrongIndent', $data); if ($fix === true) { $padding = str_repeat(' ', $expected); if ($found === 0) { $phpcsFile->fixer->addContent($prev, $padding); } else { $phpcsFile->fixer->replaceToken($prev, $padding); } } } }//end if } else if ($tokens[($className - 1)]['code'] !== T_NS_SEPARATOR || $tokens[($className - 2)]['code'] !== T_STRING ) { // Not part of a longer fully qualified class name. if ($tokens[($className - 1)]['code'] === T_COMMA || ($tokens[($className - 1)]['code'] === T_NS_SEPARATOR && $tokens[($className - 2)]['code'] === T_COMMA) ) { $error = 'Expected 1 space before "%s"; 0 found'; $data = [$tokens[$className]['content']]; $fix = $phpcsFile->addFixableError($error, ($nextComma + 1), 'NoSpaceBeforeName', $data); if ($fix === true) { $phpcsFile->fixer->addContentBefore(($nextComma + 1), ' '); } } else { if ($tokens[($className - 1)]['code'] === T_NS_SEPARATOR) { $prev = ($className - 2); } else { $prev = ($className - 1); } $last = $phpcsFile->findPrevious(T_WHITESPACE, $prev, null, true); $content = $phpcsFile->getTokensAsString(($last + 1), ($prev - $last)); if ($content !== ' ') { $found = strlen($content); $error = 'Expected 1 space before "%s"; %s found'; $data = [ $tokens[$className]['content'], $found, ]; $fix = $phpcsFile->addFixableError($error, $className, 'SpaceBeforeName', $data); if ($fix === true) { if ($tokens[$prev]['code'] === T_WHITESPACE) { $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->replaceToken($prev, ' '); while ($tokens[--$prev]['code'] === T_WHITESPACE) { $phpcsFile->fixer->replaceToken($prev, ' '); } $phpcsFile->fixer->endChangeset(); } else { $phpcsFile->fixer->addContent($prev, ' '); } } }//end if }//end if }//end if if ($checkingImplements === true && $tokens[($className + 1)]['code'] !== T_NS_SEPARATOR && $tokens[($className + 1)]['code'] !== T_COMMA ) { if ($n !== ($classCount - 1)) { // This is not the last class name, and the comma // is not where we expect it to be. if ($tokens[($className + 2)]['code'] !== $keywordTokenType) { $error = 'Expected 0 spaces between "%s" and comma; %s found'; $data = [ $tokens[$className]['content'], $tokens[($className + 1)]['length'], ]; $fix = $phpcsFile->addFixableError($error, $className, 'SpaceBeforeComma', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($className + 1), ''); } } } $nextComma = $phpcsFile->findNext(T_COMMA, $className); } else { $nextComma = ($className + 1); }//end if }//end foreach }//end processOpen() /** * Processes the closing section of a class declaration. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function processClose(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Check that the closing brace comes right after the code body. $closeBrace = $tokens[$stackPtr]['scope_closer']; $prevContent = $phpcsFile->findPrevious(T_WHITESPACE, ($closeBrace - 1), null, true); if ($prevContent !== $tokens[$stackPtr]['scope_opener'] && $tokens[$prevContent]['line'] !== ($tokens[$closeBrace]['line'] - 1) ) { $error = 'The closing brace for the %s must go on the next line after the body'; $data = [$tokens[$stackPtr]['content']]; $fix = $phpcsFile->addFixableError($error, $closeBrace, 'CloseBraceAfterBody', $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($prevContent + 1); $i < $closeBrace; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } if (strpos($tokens[$prevContent]['content'], $phpcsFile->eolChar) === false) { $phpcsFile->fixer->replaceToken($closeBrace, $phpcsFile->eolChar.$tokens[$closeBrace]['content']); } $phpcsFile->fixer->endChangeset(); } }//end if if ($tokens[$stackPtr]['code'] !== T_ANON_CLASS) { // Check the closing brace is on it's own line, but allow // for comments like "//end class". $ignoreTokens = Tokens::$phpcsCommentTokens; $ignoreTokens[] = T_WHITESPACE; $ignoreTokens[] = T_COMMENT; $ignoreTokens[] = T_SEMICOLON; $ignoreTokens[] = T_COMMA; $nextContent = $phpcsFile->findNext($ignoreTokens, ($closeBrace + 1), null, true); if ($tokens[$nextContent]['content'] !== $phpcsFile->eolChar && $tokens[$nextContent]['line'] === $tokens[$closeBrace]['line'] ) { $type = strtolower($tokens[$stackPtr]['content']); $error = 'Closing %s brace must be on a line by itself'; $data = [$type]; $phpcsFile->addError($error, $closeBrace, 'CloseBraceSameLine', $data); } } }//end processClose() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Sniffs/Classes/PropertyDeclarationSniff.php0000644000076500000240000001542413614652361030100 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR2\Sniffs\Classes; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\AbstractVariableSniff; use PHP_CodeSniffer\Util\Tokens; class PropertyDeclarationSniff extends AbstractVariableSniff { /** * Processes the function tokens within the class. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param int $stackPtr The position where the token was found. * * @return void */ protected function processMemberVar(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if ($tokens[$stackPtr]['content'][1] === '_') { $error = 'Property name "%s" should not be prefixed with an underscore to indicate visibility'; $data = [$tokens[$stackPtr]['content']]; $phpcsFile->addWarning($error, $stackPtr, 'Underscore', $data); } // Detect multiple properties defined at the same time. Throw an error // for this, but also only process the first property in the list so we don't // repeat errors. $find = Tokens::$scopeModifiers; $find[] = T_VARIABLE; $find[] = T_VAR; $find[] = T_SEMICOLON; $find[] = T_OPEN_CURLY_BRACKET; $prev = $phpcsFile->findPrevious($find, ($stackPtr - 1)); if ($tokens[$prev]['code'] === T_VARIABLE) { return; } if ($tokens[$prev]['code'] === T_VAR) { $error = 'The var keyword must not be used to declare a property'; $phpcsFile->addError($error, $stackPtr, 'VarUsed'); } $next = $phpcsFile->findNext([T_VARIABLE, T_SEMICOLON], ($stackPtr + 1)); if ($next !== false && $tokens[$next]['code'] === T_VARIABLE) { $error = 'There must not be more than one property declared per statement'; $phpcsFile->addError($error, $stackPtr, 'Multiple'); } try { $propertyInfo = $phpcsFile->getMemberProperties($stackPtr); if (empty($propertyInfo) === true) { return; } } catch (\Exception $e) { // Turns out not to be a property after all. return; } if ($propertyInfo['type'] !== '') { $typeToken = $propertyInfo['type_end_token']; $error = 'There must be 1 space after the property type declaration; %s found'; if ($tokens[($typeToken + 1)]['code'] !== T_WHITESPACE) { $data = ['0']; $fix = $phpcsFile->addFixableError($error, $typeToken, 'SpacingAfterType', $data); if ($fix === true) { $phpcsFile->fixer->addContent($typeToken, ' '); } } else if ($tokens[($typeToken + 1)]['content'] !== ' ') { $next = $phpcsFile->findNext(T_WHITESPACE, ($typeToken + 1), null, true); if ($tokens[$next]['line'] !== $tokens[$typeToken]['line']) { $found = 'newline'; } else { $found = $tokens[($typeToken + 1)]['length']; } $data = [$found]; $nextNonWs = $phpcsFile->findNext(Tokens::$emptyTokens, ($typeToken + 1), null, true); if ($nextNonWs !== $next) { $phpcsFile->addError($error, $typeToken, 'SpacingAfterType', $data); } else { $fix = $phpcsFile->addFixableError($error, $typeToken, 'SpacingAfterType', $data); if ($fix === true) { if ($found === 'newline') { $phpcsFile->fixer->beginChangeset(); for ($x = ($typeToken + 1); $x < $next; $x++) { $phpcsFile->fixer->replaceToken($x, ''); } $phpcsFile->fixer->addContent($typeToken, ' '); $phpcsFile->fixer->endChangeset(); } else { $phpcsFile->fixer->replaceToken(($typeToken + 1), ' '); } } } }//end if }//end if if ($propertyInfo['scope_specified'] === false) { $error = 'Visibility must be declared on property "%s"'; $data = [$tokens[$stackPtr]['content']]; $phpcsFile->addError($error, $stackPtr, 'ScopeMissing', $data); } if ($propertyInfo['scope_specified'] === true && $propertyInfo['is_static'] === true) { $scopePtr = $phpcsFile->findPrevious(Tokens::$scopeModifiers, ($stackPtr - 1)); $staticPtr = $phpcsFile->findPrevious(T_STATIC, ($stackPtr - 1)); if ($scopePtr < $staticPtr) { return; } $error = 'The static declaration must come after the visibility declaration'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'StaticBeforeVisibility'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($scopePtr + 1); $scopePtr < $stackPtr; $i++) { if ($tokens[$i]['code'] !== T_WHITESPACE) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->replaceToken($scopePtr, ''); $phpcsFile->fixer->addContentBefore($staticPtr, $propertyInfo['scope'].' '); $phpcsFile->fixer->endChangeset(); } }//end if }//end processMemberVar() /** * Processes normal variables. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param int $stackPtr The position where the token was found. * * @return void */ protected function processVariable(File $phpcsFile, $stackPtr) { /* We don't care about normal variables. */ }//end processVariable() /** * Processes variables in double quoted strings. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param int $stackPtr The position where the token was found. * * @return void */ protected function processVariableInString(File $phpcsFile, $stackPtr) { /* We don't care about normal variables. */ }//end processVariableInString() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Sniffs/ControlStructures/ControlStructureSpacingSniff.php0000644000076500000240000001213213614652361033074 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR2\Sniffs\ControlStructures; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class ControlStructureSpacingSniff implements Sniff { /** * How many spaces should follow the opening bracket. * * @var integer */ public $requiredSpacesAfterOpen = 0; /** * How many spaces should precede the closing bracket. * * @var integer */ public $requiredSpacesBeforeClose = 0; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_IF, T_WHILE, T_FOREACH, T_FOR, T_SWITCH, T_ELSE, T_ELSEIF, T_CATCH, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $this->requiredSpacesAfterOpen = (int) $this->requiredSpacesAfterOpen; $this->requiredSpacesBeforeClose = (int) $this->requiredSpacesBeforeClose; $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['parenthesis_opener']) === false || isset($tokens[$stackPtr]['parenthesis_closer']) === false ) { return; } $parenOpener = $tokens[$stackPtr]['parenthesis_opener']; $parenCloser = $tokens[$stackPtr]['parenthesis_closer']; $nextContent = $phpcsFile->findNext(T_WHITESPACE, ($parenOpener + 1), null, true); if (in_array($tokens[$nextContent]['code'], Tokens::$commentTokens, true) === false) { $spaceAfterOpen = 0; if ($tokens[($parenOpener + 1)]['code'] === T_WHITESPACE) { if (strpos($tokens[($parenOpener + 1)]['content'], $phpcsFile->eolChar) !== false) { $spaceAfterOpen = 'newline'; } else { $spaceAfterOpen = $tokens[($parenOpener + 1)]['length']; } } $phpcsFile->recordMetric($stackPtr, 'Spaces after control structure open parenthesis', $spaceAfterOpen); if ($spaceAfterOpen !== $this->requiredSpacesAfterOpen) { $error = 'Expected %s spaces after opening bracket; %s found'; $data = [ $this->requiredSpacesAfterOpen, $spaceAfterOpen, ]; $fix = $phpcsFile->addFixableError($error, ($parenOpener + 1), 'SpacingAfterOpenBrace', $data); if ($fix === true) { $padding = str_repeat(' ', $this->requiredSpacesAfterOpen); if ($spaceAfterOpen === 0) { $phpcsFile->fixer->addContent($parenOpener, $padding); } else if ($spaceAfterOpen === 'newline') { $phpcsFile->fixer->replaceToken(($parenOpener + 1), ''); } else { $phpcsFile->fixer->replaceToken(($parenOpener + 1), $padding); } } } }//end if $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($parenCloser - 1), $parenOpener, true); if ($tokens[$prev]['line'] === $tokens[$parenCloser]['line']) { $spaceBeforeClose = 0; if ($tokens[($parenCloser - 1)]['code'] === T_WHITESPACE) { $spaceBeforeClose = strlen(ltrim($tokens[($parenCloser - 1)]['content'], $phpcsFile->eolChar)); } $phpcsFile->recordMetric($stackPtr, 'Spaces before control structure close parenthesis', $spaceBeforeClose); if ($spaceBeforeClose !== $this->requiredSpacesBeforeClose) { $error = 'Expected %s spaces before closing bracket; %s found'; $data = [ $this->requiredSpacesBeforeClose, $spaceBeforeClose, ]; $fix = $phpcsFile->addFixableError($error, ($parenCloser - 1), 'SpaceBeforeCloseBrace', $data); if ($fix === true) { $padding = str_repeat(' ', $this->requiredSpacesBeforeClose); if ($spaceBeforeClose === 0) { $phpcsFile->fixer->addContentBefore($parenCloser, $padding); } else { $phpcsFile->fixer->replaceToken(($parenCloser - 1), $padding); } } } }//end if }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Sniffs/ControlStructures/ElseIfDeclarationSniff.php0000644000076500000240000000416513614652361031552 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR2\Sniffs\ControlStructures; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class ElseIfDeclarationSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_ELSE, T_ELSEIF, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if ($tokens[$stackPtr]['code'] === T_ELSEIF) { $phpcsFile->recordMetric($stackPtr, 'Use of ELSE IF or ELSEIF', 'elseif'); return; } $next = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($tokens[$next]['code'] === T_IF) { $phpcsFile->recordMetric($stackPtr, 'Use of ELSE IF or ELSEIF', 'else if'); $error = 'Usage of ELSE IF is discouraged; use ELSEIF instead'; $fix = $phpcsFile->addFixableWarning($error, $stackPtr, 'NotAllowed'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->replaceToken($stackPtr, 'elseif'); for ($i = ($stackPtr + 1); $i <= $next; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Sniffs/ControlStructures/SwitchDeclarationSniff.php0000644000076500000240000003340313614652361031641 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR2\Sniffs\ControlStructures; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class SwitchDeclarationSniff implements Sniff { /** * The number of spaces code should be indented. * * @var integer */ public $indent = 4; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_SWITCH]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // We can't process SWITCH statements unless we know where they start and end. if (isset($tokens[$stackPtr]['scope_opener']) === false || isset($tokens[$stackPtr]['scope_closer']) === false ) { return; } $switch = $tokens[$stackPtr]; $nextCase = $stackPtr; $caseAlignment = ($switch['column'] + $this->indent); while (($nextCase = $this->findNextCase($phpcsFile, ($nextCase + 1), $switch['scope_closer'])) !== false) { if ($tokens[$nextCase]['code'] === T_DEFAULT) { $type = 'default'; } else { $type = 'case'; } if ($tokens[$nextCase]['content'] !== strtolower($tokens[$nextCase]['content'])) { $expected = strtolower($tokens[$nextCase]['content']); $error = strtoupper($type).' keyword must be lowercase; expected "%s" but found "%s"'; $data = [ $expected, $tokens[$nextCase]['content'], ]; $fix = $phpcsFile->addFixableError($error, $nextCase, $type.'NotLower', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken($nextCase, $expected); } } if ($type === 'case' && ($tokens[($nextCase + 1)]['code'] !== T_WHITESPACE || $tokens[($nextCase + 1)]['content'] !== ' ') ) { $error = 'CASE keyword must be followed by a single space'; $fix = $phpcsFile->addFixableError($error, $nextCase, 'SpacingAfterCase'); if ($fix === true) { if ($tokens[($nextCase + 1)]['code'] !== T_WHITESPACE) { $phpcsFile->fixer->addContent($nextCase, ' '); } else { $phpcsFile->fixer->replaceToken(($nextCase + 1), ' '); } } } $opener = $tokens[$nextCase]['scope_opener']; $nextCloser = $tokens[$nextCase]['scope_closer']; if ($tokens[$opener]['code'] === T_COLON) { if ($tokens[($opener - 1)]['code'] === T_WHITESPACE) { $error = 'There must be no space before the colon in a '.strtoupper($type).' statement'; $fix = $phpcsFile->addFixableError($error, $nextCase, 'SpaceBeforeColon'.strtoupper($type)); if ($fix === true) { $phpcsFile->fixer->replaceToken(($opener - 1), ''); } } $next = $phpcsFile->findNext(T_WHITESPACE, ($opener + 1), null, true); if ($tokens[$next]['line'] === $tokens[$opener]['line'] && ($tokens[$next]['code'] === T_COMMENT || isset(Tokens::$phpcsCommentTokens[$tokens[$next]['code']]) === true) ) { // Skip comments on the same line. $next = $phpcsFile->findNext(T_WHITESPACE, ($next + 1), null, true); } if ($tokens[$next]['line'] !== ($tokens[$opener]['line'] + 1)) { $error = 'The '.strtoupper($type).' body must start on the line following the statement'; $fix = $phpcsFile->addFixableError($error, $nextCase, 'BodyOnNextLine'.strtoupper($type)); if ($fix === true) { if ($tokens[$next]['line'] === $tokens[$opener]['line']) { $padding = str_repeat(' ', ($caseAlignment + $this->indent - 1)); $phpcsFile->fixer->addContentBefore($next, $phpcsFile->eolChar.$padding); } else { $phpcsFile->fixer->beginChangeset(); for ($i = ($opener + 1); $i < $next; $i++) { if ($tokens[$i]['line'] === $tokens[$next]['line']) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->addNewLineBefore($i); $phpcsFile->fixer->endChangeset(); } } }//end if if ($tokens[$nextCloser]['scope_condition'] === $nextCase) { // Only need to check some things once, even if the // closer is shared between multiple case statements, or even // the default case. $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($nextCloser - 1), $nextCase, true); if ($tokens[$prev]['line'] === $tokens[$nextCloser]['line']) { $error = 'Terminating statement must be on a line by itself'; $fix = $phpcsFile->addFixableError($error, $nextCloser, 'BreakNotNewLine'); if ($fix === true) { $phpcsFile->fixer->addNewLine($prev); $phpcsFile->fixer->replaceToken($nextCloser, trim($tokens[$nextCloser]['content'])); } } else { $diff = ($caseAlignment + $this->indent - $tokens[$nextCloser]['column']); if ($diff !== 0) { $error = 'Terminating statement must be indented to the same level as the CASE body'; $fix = $phpcsFile->addFixableError($error, $nextCloser, 'BreakIndent'); if ($fix === true) { if ($diff > 0) { $phpcsFile->fixer->addContentBefore($nextCloser, str_repeat(' ', $diff)); } else { $phpcsFile->fixer->substrToken(($nextCloser - 1), 0, $diff); } } } }//end if }//end if } else { $error = strtoupper($type).' statements must be defined using a colon'; $phpcsFile->addError($error, $nextCase, 'WrongOpener'.$type); }//end if // We only want cases from here on in. if ($type !== 'case') { continue; } $nextCode = $phpcsFile->findNext(T_WHITESPACE, ($opener + 1), $nextCloser, true); if ($tokens[$nextCode]['code'] !== T_CASE && $tokens[$nextCode]['code'] !== T_DEFAULT) { // This case statement has content. If the next case or default comes // before the closer, it means we don't have an obvious terminating // statement and need to make some more effort to find one. If we // don't, we do need a comment. $nextCode = $this->findNextCase($phpcsFile, ($opener + 1), $nextCloser); if ($nextCode !== false) { $prevCode = $phpcsFile->findPrevious(T_WHITESPACE, ($nextCode - 1), $nextCase, true); if ($tokens[$prevCode]['code'] !== T_COMMENT && $this->findNestedTerminator($phpcsFile, ($opener + 1), $nextCode) === false ) { $error = 'There must be a comment when fall-through is intentional in a non-empty case body'; $phpcsFile->addError($error, $nextCase, 'TerminatingComment'); } } } }//end while }//end process() /** * Find the next CASE or DEFAULT statement from a point in the file. * * Note that nested switches are ignored. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position to start looking at. * @param int $end The position to stop looking at. * * @return int|false */ private function findNextCase($phpcsFile, $stackPtr, $end) { $tokens = $phpcsFile->getTokens(); while (($stackPtr = $phpcsFile->findNext([T_CASE, T_DEFAULT, T_SWITCH], $stackPtr, $end)) !== false) { // Skip nested SWITCH statements; they are handled on their own. if ($tokens[$stackPtr]['code'] === T_SWITCH) { $stackPtr = $tokens[$stackPtr]['scope_closer']; continue; } break; } return $stackPtr; }//end findNextCase() /** * Returns true if a nested terminating statement is found. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position to start looking at. * @param int $end The position to stop looking at. * * @return bool */ private function findNestedTerminator($phpcsFile, $stackPtr, $end) { $tokens = $phpcsFile->getTokens(); $terminators = [ T_RETURN, T_BREAK, T_CONTINUE, T_THROW, T_EXIT, ]; $lastToken = $phpcsFile->findPrevious(T_WHITESPACE, ($end - 1), $stackPtr, true); if ($lastToken !== false) { if ($tokens[$lastToken]['code'] === T_CLOSE_CURLY_BRACKET) { // We found a closing curly bracket and want to check if its // block belongs to an IF, ELSEIF or ELSE clause. If yes, we // continue searching for a terminating statement within that // block. Note that we have to make sure that every block of // the entire if/else statement has a terminating statement. $currentCloser = $lastToken; $hasElseBlock = false; do { $scopeOpener = $tokens[$currentCloser]['scope_opener']; $scopeCloser = $tokens[$currentCloser]['scope_closer']; $prevToken = $phpcsFile->findPrevious(T_WHITESPACE, ($scopeOpener - 1), $stackPtr, true); if ($prevToken === false) { return false; } // IF and ELSEIF clauses possess a condition we have to account for. if ($tokens[$prevToken]['code'] === T_CLOSE_PARENTHESIS) { $prevToken = $tokens[$prevToken]['parenthesis_owner']; } if ($tokens[$prevToken]['code'] === T_IF) { // If we have not encountered an ELSE clause by now, we cannot // be sure that the whole statement terminates in every case. if ($hasElseBlock === false) { return false; } return $this->findNestedTerminator($phpcsFile, ($scopeOpener + 1), $scopeCloser); } else if ($tokens[$prevToken]['code'] === T_ELSEIF || $tokens[$prevToken]['code'] === T_ELSE ) { // If we find a terminating statement within this block, // we continue with the previous ELSEIF or IF clause. $hasTerminator = $this->findNestedTerminator($phpcsFile, ($scopeOpener + 1), $scopeCloser); if ($hasTerminator === false) { return false; } $currentCloser = $phpcsFile->findPrevious(T_WHITESPACE, ($prevToken - 1), $stackPtr, true); if ($tokens[$prevToken]['code'] === T_ELSE) { $hasElseBlock = true; } } else { return false; }//end if } while ($currentCloser !== false && $tokens[$currentCloser]['code'] === T_CLOSE_CURLY_BRACKET); return true; } else if ($tokens[$lastToken]['code'] === T_SEMICOLON) { // We found the last statement of the CASE. Now we want to // check whether it is a terminating one. $terminator = $phpcsFile->findStartOfStatement(($lastToken - 1)); if (in_array($tokens[$terminator]['code'], $terminators, true) === true) { return $terminator; } }//end if }//end if return false; }//end findNestedTerminator() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Sniffs/Files/ClosingTagSniff.php0000644000076500000240000000534613614652361025607 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR2\Sniffs\Files; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class ClosingTagSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return int */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Make sure this file only contains PHP code. for ($i = 0; $i < $phpcsFile->numTokens; $i++) { if ($tokens[$i]['code'] === T_INLINE_HTML && trim($tokens[$i]['content']) !== '' ) { return $phpcsFile->numTokens; } } // Find the last non-empty token. for ($last = ($phpcsFile->numTokens - 1); $last > 0; $last--) { if (trim($tokens[$last]['content']) !== '') { break; } } if ($tokens[$last]['code'] === T_CLOSE_TAG) { $error = 'A closing tag is not permitted at the end of a PHP file'; $fix = $phpcsFile->addFixableError($error, $last, 'NotAllowed'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->replaceToken($last, $phpcsFile->eolChar); $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($last - 1), null, true); if ($tokens[$prev]['code'] !== T_SEMICOLON && $tokens[$prev]['code'] !== T_CLOSE_CURLY_BRACKET ) { $phpcsFile->fixer->addContent($prev, ';'); } $phpcsFile->fixer->endChangeset(); } $phpcsFile->recordMetric($stackPtr, 'PHP closing tag at end of PHP-only file', 'yes'); } else { $phpcsFile->recordMetric($stackPtr, 'PHP closing tag at end of PHP-only file', 'no'); } // Ignore the rest of the file. return $phpcsFile->numTokens; }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Sniffs/Files/EndFileNewlineSniff.php0000644000076500000240000000665413614652361026410 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR2\Sniffs\Files; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class EndFileNewlineSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { if ($phpcsFile->findNext(T_INLINE_HTML, ($stackPtr + 1)) !== false) { return ($phpcsFile->numTokens + 1); } // Skip to the end of the file. $tokens = $phpcsFile->getTokens(); $lastToken = ($phpcsFile->numTokens - 1); if ($tokens[$lastToken]['content'] === '') { $lastToken--; } // Hard-coding the expected \n in this sniff as it is PSR-2 specific and // PSR-2 enforces the use of unix style newlines. if (substr($tokens[$lastToken]['content'], -1) !== "\n") { $error = 'Expected 1 newline at end of file; 0 found'; $fix = $phpcsFile->addFixableError($error, $lastToken, 'NoneFound'); if ($fix === true) { $phpcsFile->fixer->addNewline($lastToken); } $phpcsFile->recordMetric($stackPtr, 'Number of newlines at EOF', '0'); return ($phpcsFile->numTokens + 1); } // Go looking for the last non-empty line. $lastLine = $tokens[$lastToken]['line']; if ($tokens[$lastToken]['code'] === T_WHITESPACE || $tokens[$lastToken]['code'] === T_DOC_COMMENT_WHITESPACE ) { $lastCode = $phpcsFile->findPrevious([T_WHITESPACE, T_DOC_COMMENT_WHITESPACE], ($lastToken - 1), null, true); } else { $lastCode = $lastToken; } $lastCodeLine = $tokens[$lastCode]['line']; $blankLines = ($lastLine - $lastCodeLine + 1); $phpcsFile->recordMetric($stackPtr, 'Number of newlines at EOF', $blankLines); if ($blankLines > 1) { $error = 'Expected 1 blank line at end of file; %s found'; $data = [$blankLines]; $fix = $phpcsFile->addFixableError($error, $lastCode, 'TooMany', $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->replaceToken($lastCode, rtrim($tokens[$lastCode]['content'])); for ($i = ($lastCode + 1); $i < $lastToken; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->replaceToken($lastToken, $phpcsFile->eolChar); $phpcsFile->fixer->endChangeset(); } } // Skip the rest of the file. return ($phpcsFile->numTokens + 1); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Sniffs/Methods/FunctionCallSignatureSniff.php0000644000076500000240000000556213614652361030361 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR2\Sniffs\Methods; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Standards\PEAR\Sniffs\Functions\FunctionCallSignatureSniff as PEARFunctionCallSignatureSniff; use PHP_CodeSniffer\Util\Tokens; class FunctionCallSignatureSniff extends PEARFunctionCallSignatureSniff { /** * If TRUE, multiple arguments can be defined per line in a multi-line call. * * @var boolean */ public $allowMultipleArguments = false; /** * Processes single-line calls. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param int $openBracket The position of the opening bracket * in the stack passed in $tokens. * @param array $tokens The stack of tokens that make up * the file. * * @return void */ public function isMultiLineCall(File $phpcsFile, $stackPtr, $openBracket, $tokens) { // If the first argument is on a new line, this is a multi-line // function call, even if there is only one argument. $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($openBracket + 1), null, true); if ($tokens[$next]['line'] !== $tokens[$stackPtr]['line']) { return true; } $closeBracket = $tokens[$openBracket]['parenthesis_closer']; $end = $phpcsFile->findEndOfStatement($openBracket + 1); while ($tokens[$end]['code'] === T_COMMA) { // If the next bit of code is not on the same line, this is a // multi-line function call. $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($end + 1), $closeBracket, true); if ($next === false) { return false; } if ($tokens[$next]['line'] !== $tokens[$end]['line']) { return true; } $end = $phpcsFile->findEndOfStatement($next); } // We've reached the last argument, so see if the next content // (should be the close bracket) is also on the same line. $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($end + 1), $closeBracket, true); if ($next !== false && $tokens[$next]['line'] !== $tokens[$end]['line']) { return true; } return false; }//end isMultiLineCall() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Sniffs/Methods/FunctionClosingBraceSniff.php0000644000076500000240000000515013614652361030150 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR2\Sniffs\Methods; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class FunctionClosingBraceSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_FUNCTION, T_CLOSURE, ]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['scope_closer']) === false) { // Probably an interface method. return; } $closeBrace = $tokens[$stackPtr]['scope_closer']; $prevContent = $phpcsFile->findPrevious(T_WHITESPACE, ($closeBrace - 1), null, true); $found = ($tokens[$closeBrace]['line'] - $tokens[$prevContent]['line'] - 1); if ($found < 0) { // Brace isn't on a new line, so not handled by us. return; } if ($found === 0) { // All is good. return; } $error = 'Function closing brace must go on the next line following the body; found %s blank lines before brace'; $data = [$found]; $fix = $phpcsFile->addFixableError($error, $closeBrace, 'SpacingBeforeClose', $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($prevContent + 1); $i < $closeBrace; $i++) { if ($tokens[$i]['line'] === $tokens[$prevContent]['line']) { continue; } // Don't remove any indentation before the brace. if ($tokens[$i]['line'] === $tokens[$closeBrace]['line']) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Sniffs/Methods/MethodDeclarationSniff.php0000644000076500000240000001303313614652361027474 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR2\Sniffs\Methods; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\AbstractScopeSniff; use PHP_CodeSniffer\Util\Tokens; class MethodDeclarationSniff extends AbstractScopeSniff { /** * Constructs a Squiz_Sniffs_Scope_MethodScopeSniff. */ public function __construct() { parent::__construct(Tokens::$ooScopeTokens, [T_FUNCTION]); }//end __construct() /** * Processes the function tokens within the class. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param int $stackPtr The position where the token was found. * @param int $currScope The current scope opener token. * * @return void */ protected function processTokenWithinScope(File $phpcsFile, $stackPtr, $currScope) { $tokens = $phpcsFile->getTokens(); // Determine if this is a function which needs to be examined. $conditions = $tokens[$stackPtr]['conditions']; end($conditions); $deepestScope = key($conditions); if ($deepestScope !== $currScope) { return; } $methodName = $phpcsFile->getDeclarationName($stackPtr); if ($methodName === null) { // Ignore closures. return; } if ($methodName[0] === '_' && isset($methodName[1]) === true && $methodName[1] !== '_') { $error = 'Method name "%s" should not be prefixed with an underscore to indicate visibility'; $data = [$methodName]; $phpcsFile->addWarning($error, $stackPtr, 'Underscore', $data); } $visibility = 0; $static = 0; $abstract = 0; $final = 0; $find = (Tokens::$methodPrefixes + Tokens::$emptyTokens); $prev = $phpcsFile->findPrevious($find, ($stackPtr - 1), null, true); $prefix = $stackPtr; while (($prefix = $phpcsFile->findPrevious(Tokens::$methodPrefixes, ($prefix - 1), $prev)) !== false) { switch ($tokens[$prefix]['code']) { case T_STATIC: $static = $prefix; break; case T_ABSTRACT: $abstract = $prefix; break; case T_FINAL: $final = $prefix; break; default: $visibility = $prefix; break; } } $fixes = []; if ($visibility !== 0 && $final > $visibility) { $error = 'The final declaration must precede the visibility declaration'; $fix = $phpcsFile->addFixableError($error, $final, 'FinalAfterVisibility'); if ($fix === true) { $fixes[$final] = ''; $fixes[($final + 1)] = ''; if (isset($fixes[$visibility]) === true) { $fixes[$visibility] = 'final '.$fixes[$visibility]; } else { $fixes[$visibility] = 'final '.$tokens[$visibility]['content']; } } } if ($visibility !== 0 && $abstract > $visibility) { $error = 'The abstract declaration must precede the visibility declaration'; $fix = $phpcsFile->addFixableError($error, $abstract, 'AbstractAfterVisibility'); if ($fix === true) { $fixes[$abstract] = ''; $fixes[($abstract + 1)] = ''; if (isset($fixes[$visibility]) === true) { $fixes[$visibility] = 'abstract '.$fixes[$visibility]; } else { $fixes[$visibility] = 'abstract '.$tokens[$visibility]['content']; } } } if ($static !== 0 && $static < $visibility) { $error = 'The static declaration must come after the visibility declaration'; $fix = $phpcsFile->addFixableError($error, $static, 'StaticBeforeVisibility'); if ($fix === true) { $fixes[$static] = ''; $fixes[($static + 1)] = ''; if (isset($fixes[$visibility]) === true) { $fixes[$visibility] .= ' static'; } else { $fixes[$visibility] = $tokens[$visibility]['content'].' static'; } } } // Batch all the fixes together to reduce the possibility of conflicts. if (empty($fixes) === false) { $phpcsFile->fixer->beginChangeset(); foreach ($fixes as $stackPtr => $content) { $phpcsFile->fixer->replaceToken($stackPtr, $content); } $phpcsFile->fixer->endChangeset(); } }//end processTokenWithinScope() /** * Processes a token that is found within the scope that this test is * listening to. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param int $stackPtr The position in the stack where this * token was found. * * @return void */ protected function processTokenOutsideScope(File $phpcsFile, $stackPtr) { }//end processTokenOutsideScope() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Sniffs/Namespaces/NamespaceDeclarationSniff.php0000644000076500000240000000510513614652361030625 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR2\Sniffs\Namespaces; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class NamespaceDeclarationSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_NAMESPACE]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $end = $phpcsFile->findEndOfStatement($stackPtr); for ($i = ($end + 1); $i < ($phpcsFile->numTokens - 1); $i++) { if ($tokens[$i]['line'] === $tokens[$end]['line']) { continue; } break; } // The $i var now points to the first token on the line after the // namespace declaration, which must be a blank line. $next = $phpcsFile->findNext(T_WHITESPACE, $i, $phpcsFile->numTokens, true); if ($next === false) { return; } $diff = ($tokens[$next]['line'] - $tokens[$i]['line']); if ($diff === 1) { return; } if ($diff < 0) { $diff = 0; } $error = 'There must be one blank line after the namespace declaration'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'BlankLineAfter'); if ($fix === true) { if ($diff === 0) { $phpcsFile->fixer->addNewlineBefore($i); } else { $phpcsFile->fixer->beginChangeset(); for ($x = $i; $x < $next; $x++) { if ($tokens[$x]['line'] === $tokens[$next]['line']) { break; } $phpcsFile->fixer->replaceToken($x, ''); } $phpcsFile->fixer->addNewline($i); $phpcsFile->fixer->endChangeset(); } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Sniffs/Namespaces/UseDeclarationSniff.php0000644000076500000240000002763313614652361027477 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR2\Sniffs\Namespaces; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class UseDeclarationSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_USE]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { if ($this->shouldIgnoreUse($phpcsFile, $stackPtr) === true) { return; } $tokens = $phpcsFile->getTokens(); // One space after the use keyword. if ($tokens[($stackPtr + 1)]['content'] !== ' ') { $error = 'There must be a single space after the USE keyword'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceAfterUse'); if ($fix === true) { $phpcsFile->fixer->replaceToken(($stackPtr + 1), ' '); } } // Only one USE declaration allowed per statement. $next = $phpcsFile->findNext([T_COMMA, T_SEMICOLON, T_OPEN_USE_GROUP, T_CLOSE_TAG], ($stackPtr + 1)); if ($next !== false && $tokens[$next]['code'] !== T_SEMICOLON && $tokens[$next]['code'] !== T_CLOSE_TAG ) { $error = 'There must be one USE keyword per declaration'; if ($tokens[$next]['code'] === T_COMMA) { $fix = $phpcsFile->addFixableError($error, $stackPtr, 'MultipleDeclarations'); if ($fix === true) { switch ($tokens[($stackPtr + 2)]['content']) { case 'const': $baseUse = 'use const'; break; case 'function': $baseUse = 'use function'; break; default: $baseUse = 'use'; } $phpcsFile->fixer->replaceToken($next, ';'.$phpcsFile->eolChar.$baseUse); } } else { $closingCurly = $phpcsFile->findNext(T_CLOSE_USE_GROUP, ($next + 1)); if ($closingCurly === false) { // Parse error or live coding. Not auto-fixable. $phpcsFile->addError($error, $stackPtr, 'MultipleDeclarations'); } else { $fix = $phpcsFile->addFixableError($error, $stackPtr, 'MultipleDeclarations'); if ($fix === true) { $baseUse = rtrim($phpcsFile->getTokensAsString($stackPtr, ($next - $stackPtr))); $lastNonWhitespace = $phpcsFile->findPrevious(T_WHITESPACE, ($closingCurly - 1), null, true); $phpcsFile->fixer->beginChangeset(); // Remove base use statement. for ($i = $stackPtr; $i <= $next; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } if (preg_match('`^[\r\n]+$`', $tokens[($next + 1)]['content']) === 1) { $phpcsFile->fixer->replaceToken(($next + 1), ''); } // Convert grouped use statements into full use statements. do { $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($next + 1), $closingCurly, true); if ($next === false) { // Group use statement with trailing comma after last item. break; } $nonWhitespace = $phpcsFile->findPrevious(T_WHITESPACE, ($next - 1), null, true); for ($i = ($nonWhitespace + 1); $i < $next; $i++) { if (preg_match('`^[\r\n]+$`', $tokens[$i]['content']) === 1) { // Preserve new lines. continue; } $phpcsFile->fixer->replaceToken($i, ''); } if ($tokens[$next]['content'] === 'const' || $tokens[$next]['content'] === 'function') { $phpcsFile->fixer->addContentBefore($next, 'use '); $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($next + 1), $closingCurly, true); $phpcsFile->fixer->addContentBefore($next, str_replace('use ', '', $baseUse)); } else { $phpcsFile->fixer->addContentBefore($next, $baseUse); } $next = $phpcsFile->findNext(T_COMMA, ($next + 1), $closingCurly); if ($next !== false) { $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($next + 1), $closingCurly, true); if ($nextNonEmpty !== false && $tokens[$nextNonEmpty]['line'] === $tokens[$next]['line']) { $prevNonWhitespace = $phpcsFile->findPrevious(T_WHITESPACE, ($nextNonEmpty - 1), $next, true); if ($prevNonWhitespace === $next) { $phpcsFile->fixer->replaceToken($next, ';'.$phpcsFile->eolChar); } else { $phpcsFile->fixer->replaceToken($next, ';'); $phpcsFile->fixer->addNewline($prevNonWhitespace); } } else { // Last item with trailing comma or next item already on new line. $phpcsFile->fixer->replaceToken($next, ';'); } } else { // Last item without trailing comma. $phpcsFile->fixer->addContent($lastNonWhitespace, ';'); } } while ($next !== false); // Remove closing curly,semi-colon and any whitespace between last child and closing curly. $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($closingCurly + 1), null, true); if ($next === false || $tokens[$next]['code'] !== T_SEMICOLON) { // Parse error, forgotten semi-colon. $next = $closingCurly; } for ($i = ($lastNonWhitespace + 1); $i <= $next; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); }//end if }//end if }//end if }//end if // Make sure this USE comes after the first namespace declaration. $prev = $phpcsFile->findPrevious(T_NAMESPACE, ($stackPtr - 1)); if ($prev === false) { $next = $phpcsFile->findNext(T_NAMESPACE, ($stackPtr + 1)); if ($next !== false) { $error = 'USE declarations must go after the namespace declaration'; $phpcsFile->addError($error, $stackPtr, 'UseBeforeNamespace'); } } // Only interested in the last USE statement from here onwards. $nextUse = $phpcsFile->findNext(T_USE, ($stackPtr + 1)); while ($this->shouldIgnoreUse($phpcsFile, $nextUse) === true) { $nextUse = $phpcsFile->findNext(T_USE, ($nextUse + 1)); if ($nextUse === false) { break; } } if ($nextUse !== false) { return; } $end = $phpcsFile->findNext([T_SEMICOLON, T_CLOSE_USE_GROUP, T_CLOSE_TAG], ($stackPtr + 1)); if ($end === false) { return; } if ($tokens[$end]['code'] === T_CLOSE_USE_GROUP) { $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($end + 1), null, true); if ($tokens[$nextNonEmpty]['code'] === T_SEMICOLON) { $end = $nextNonEmpty; } } // Find either the start of the next line or the beginning of the next statement, // whichever comes first. for ($end = ++$end; $end < $phpcsFile->numTokens; $end++) { if (isset(Tokens::$emptyTokens[$tokens[$end]['code']]) === false) { break; } if ($tokens[$end]['column'] === 1) { // Reached the next line. break; } } --$end; if (($tokens[$end]['code'] === T_COMMENT || isset(Tokens::$phpcsCommentTokens[$tokens[$end]['code']]) === true) && substr($tokens[$end]['content'], 0, 2) === '/*' && substr($tokens[$end]['content'], -2) !== '*/' ) { // Multi-line block comments are not allowed as trailing comment after a use statement. --$end; } $next = $phpcsFile->findNext(T_WHITESPACE, ($end + 1), null, true); if ($next === false || $tokens[$next]['code'] === T_CLOSE_TAG) { return; } $diff = ($tokens[$next]['line'] - $tokens[$end]['line'] - 1); if ($diff !== 1) { if ($diff < 0) { $diff = 0; } $error = 'There must be one blank line after the last USE statement; %s found;'; $data = [$diff]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceAfterLastUse', $data); if ($fix === true) { if ($diff === 0) { $phpcsFile->fixer->addNewline($end); } else { $phpcsFile->fixer->beginChangeset(); for ($i = ($end + 1); $i < $next; $i++) { if ($tokens[$i]['line'] === $tokens[$next]['line']) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->addNewline($end); $phpcsFile->fixer->endChangeset(); } } }//end if }//end process() /** * Check if this use statement is part of the namespace block. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return bool */ private function shouldIgnoreUse($phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Ignore USE keywords inside closures and during live coding. $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true); if ($next === false || $tokens[$next]['code'] === T_OPEN_PARENTHESIS) { return true; } // Ignore USE keywords for traits. if ($phpcsFile->hasCondition($stackPtr, [T_CLASS, T_TRAIT]) === true) { return true; } return false; }//end shouldIgnoreUse() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/Classes/ClassDeclarationUnitTest.inc0000644000076500000240000000603713614652361027667 0ustar gsherwoodstaffanonymous = new class extends ArrayObject { public function __construct() { parent::__construct(['a' => 1, 'b' => 2]); } }; } } class A extends B implements C { } class C2 { } // phpcs:ignore Standard.Category.Sniff interface I1 extends Foo { } interface I2 extends Bar { } interface I3 extends Foo, Bar { } class C1 extends Foo { } class C2 extends Bar { } class C3 extends Foo implements Bar { } class C4 extends Foo implements Bar { } class C5 extends Foo implements Bar, Baz { } class C6 extends \Foo\Bar implements \Baz\Bar { } interface I4 extends \Baz \Bar { } interface I5 extends /* comment */ \Foo\Bar { } interface I6 extends // comment \Foo\Bar { } class C7 extends // comment \Foo\Bar implements \Baz\Bar { } class C8 { } foo(new class { }); PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/Classes/ClassDeclarationUnitTest.inc.fixed0000644000076500000240000000606113614652361030762 0ustar gsherwoodstaffanonymous = new class extends ArrayObject { public function __construct() { parent::__construct(['a' => 1, 'b' => 2]); } }; } } class A extends B implements C { } class C2 { } // phpcs:ignore Standard.Category.Sniff interface I1 extends Foo { } interface I2 extends Bar { } interface I3 extends Foo, Bar { } class C1 extends Foo { } class C2 extends Bar { } class C3 extends Foo implements Bar { } class C4 extends Foo implements Bar { } class C5 extends Foo implements Bar, Baz { } class C6 extends \Foo\Bar implements \Baz\Bar { } interface I4 extends \Baz\Bar { } interface I5 extends /* comment */ \Foo\Bar { } interface I6 extends // comment \Foo\Bar { } class C7 extends \Foo\Bar implements \Baz\Bar // comment { } class C8 { } foo(new class { }); PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/Classes/ClassDeclarationUnitTest.php0000644000076500000240000000372713614652361027710 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR2\Tests\Classes; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ClassDeclarationUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 2 => 1, 7 => 3, 12 => 1, 13 => 1, 17 => 1, 19 => 2, 20 => 1, 21 => 1, 22 => 1, 25 => 1, 27 => 2, 34 => 1, 35 => 2, 44 => 1, 45 => 1, 63 => 1, 95 => 1, 116 => 1, 118 => 1, 119 => 1, 124 => 1, 130 => 2, 131 => 1, 158 => 1, 168 => 1, 178 => 1, 179 => 1, 184 => 1, 189 => 1, 194 => 1, 204 => 1, 205 => 1, 210 => 1, 215 => 2, 216 => 1, 231 => 2, 235 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/Classes/PropertyDeclarationUnitTest.inc0000644000076500000240000000226113614652361030441 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR2\Tests\Classes; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class PropertyDeclarationUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 7 => 1, 9 => 2, 10 => 1, 11 => 1, 17 => 1, 18 => 1, 23 => 1, 38 => 1, 41 => 1, 42 => 1, 50 => 2, 51 => 1, 55 => 1, 56 => 1, 61 => 1, 62 => 1, 68 => 1, 69 => 1, 71 => 1, 72 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return [ 13 => 1, 14 => 1, 15 => 1, 53 => 1, ]; }//end getWarningList() }//end class ././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/ControlStructures/ControlStructureSpacingUnitTest.incPHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/ControlStructures/ControlStructureSpacingUnitTest.inc0000644000076500000240000000240013614652361033437 0ustar gsherwoodstaff $that) {} foreach ( $something as $blah => $that ) {} foreach ( $something as $blah => $that ) {} // phpcs:set PSR2.ControlStructures.ControlStructureSpacing requiredSpacesAfterOpen 0 // phpcs:set PSR2.ControlStructures.ControlStructureSpacing requiredSpacesBeforeClose 0 $binary = b"binary string"; if ($expr1 && $expr2 ) { } if ($expr1 && $expr2 /* comment */ ) { } if ($expr1 && $expr2 /* comment */ ) { } ././@LongLink0000000000000000000000000000015200000000000007753 Lustar PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/ControlStructures/ControlStructureSpacingUnitTest.inc.fixedPHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/ControlStructures/ControlStructureSpacingUnitTest.inc0000644000076500000240000000233513614652361033446 0ustar gsherwoodstaff $that ) {} foreach ( $something as $blah => $that ) {} foreach ( $something as $blah => $that ) {} // phpcs:set PSR2.ControlStructures.ControlStructureSpacing requiredSpacesAfterOpen 0 // phpcs:set PSR2.ControlStructures.ControlStructureSpacing requiredSpacesBeforeClose 0 $binary = b"binary string"; if ($expr1 && $expr2) { } if ($expr1 && $expr2 /* comment */) { } if ($expr1 && $expr2 /* comment */) { } ././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/ControlStructures/ControlStructureSpacingUnitTest.phpPHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/ControlStructures/ControlStructureSpacingUnitTest.php0000644000076500000240000000261313614652361033463 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR2\Tests\ControlStructures; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ControlStructureSpacingUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 4 => 1, 14 => 2, 26 => 2, 27 => 2, 31 => 1, 51 => 2, 53 => 2, 60 => 1, 64 => 1, 69 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/ControlStructures/ElseIfDeclarationUnitTest.inc0000644000076500000240000000027513614652361032116 0ustar gsherwoodstaff././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/ControlStructures/ElseIfDeclarationUnitTest.inc.fixedPHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/ControlStructures/ElseIfDeclarationUnitTest.inc.fixed0000644000076500000240000000027313614652361033212 0ustar gsherwoodstaffPHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/ControlStructures/ElseIfDeclarationUnitTest.php0000644000076500000240000000233713614652361032135 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR2\Tests\ControlStructures; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ElseIfDeclarationUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return []; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return [ 4 => 1, 12 => 1, ]; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/ControlStructures/SwitchDeclarationUnitTest.inc0000644000076500000240000001047613614652361032214 0ustar gsherwoodstaff 0) { return 0; } else { return 1; } case 2: return 2; } // ERROR: No else clause switch ($foo) { case 1: if ($bar > 0) { return 0; } elseif ($bar < 0) { return 1; } case 2: return 2; } // OK: No fall-through present switch ($foo) { case 1: if ($bar > 0) { return 0; } elseif ($bar < 0) { return 1; } } // ERROR: No else clause (nested) switch ($foo) { case 1: if ($bar > 0) { return 0; } else { if ($foo > $bar) { continue; } } case 2: return 2; } // OK: Every clause terminates switch ($foo) { case 1: if ($bar > 0) { return 0; } else { if ($foo > $bar) { continue; } else { break; } } case 2: return 2; } // ERROR: Non-termination IF clause switch ($foo) { case 1: if ($bar > 0) { $offset = 0; } else { break; } case 2: return 2; } // ERROR: Non-termination IF clause (nested) switch ($foo) { case 1: if ($bar > 0) { continue; } else { if ($foo > $bar) { $offset = 0; } else { break; } } case 2: return 2; } switch ($sContext) { case 'SOMETHING': case 'CONSTANT': do_something(); break; case 'GLOBAL': case 'GLOBAL1': do_something(); // Fall through default: { do_something(); } } $foo = $foo ? function () { switch ($a) { case 'a': break; } } : null; ././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/ControlStructures/SwitchDeclarationUnitTest.inc.fixedPHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/ControlStructures/SwitchDeclarationUnitTest.inc.fixed0000644000076500000240000001054413614652361033306 0ustar gsherwoodstaff 0) { return 0; } else { return 1; } case 2: return 2; } // ERROR: No else clause switch ($foo) { case 1: if ($bar > 0) { return 0; } elseif ($bar < 0) { return 1; } case 2: return 2; } // OK: No fall-through present switch ($foo) { case 1: if ($bar > 0) { return 0; } elseif ($bar < 0) { return 1; } } // ERROR: No else clause (nested) switch ($foo) { case 1: if ($bar > 0) { return 0; } else { if ($foo > $bar) { continue; } } case 2: return 2; } // OK: Every clause terminates switch ($foo) { case 1: if ($bar > 0) { return 0; } else { if ($foo > $bar) { continue; } else { break; } } case 2: return 2; } // ERROR: Non-termination IF clause switch ($foo) { case 1: if ($bar > 0) { $offset = 0; } else { break; } case 2: return 2; } // ERROR: Non-termination IF clause (nested) switch ($foo) { case 1: if ($bar > 0) { continue; } else { if ($foo > $bar) { $offset = 0; } else { break; } } case 2: return 2; } switch ($sContext) { case 'SOMETHING': case 'CONSTANT': do_something(); break; case 'GLOBAL': case 'GLOBAL1': do_something(); // Fall through default: { do_something(); } } $foo = $foo ? function () { switch ($a) { case 'a': break; } } : null; PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/ControlStructures/SwitchDeclarationUnitTest.php0000644000076500000240000000320313614652361032220 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR2\Tests\ControlStructures; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class SwitchDeclarationUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 10 => 1, 11 => 1, 14 => 1, 16 => 1, 20 => 1, 23 => 1, 29 => 1, 33 => 1, 37 => 2, 108 => 2, 109 => 1, 111 => 1, 113 => 2, 114 => 1, 128 => 1, 141 => 1, 172 => 1, 194 => 1, 224 => 1, 236 => 1, 260 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/Files/ClosingTagUnitTest.1.inc0000644000076500000240000000006513614652361026305 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/Files/ClosingTagUnitTest.1.inc.fixed0000644000076500000240000000006313614652361027401 0ustar gsherwoodstaff
    PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/Files/ClosingTagUnitTest.3.inc0000644000076500000240000000012113614652361026300 0ustar gsherwoodstaff A: B: C: PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/Files/ClosingTagUnitTest.4.inc0000644000076500000240000000003313614652361026303 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/Files/ClosingTagUnitTest.4.inc.fixed0000644000076500000240000000003213614652361027400 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/Files/ClosingTagUnitTest.5.inc.fixed0000644000076500000240000000006513614652361027407 0ustar gsherwoodstaffPHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/Files/ClosingTagUnitTest.6.inc.fixed0000644000076500000240000000020513614652361027404 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR2\Tests\Files; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ClosingTagUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='') { switch ($testFile) { case 'ClosingTagUnitTest.1.inc': return [11 => 1]; case 'ClosingTagUnitTest.4.inc': case 'ClosingTagUnitTest.5.inc': return [1 => 1]; case 'ClosingTagUnitTest.6.inc': return [5 => 1]; default: return []; } }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/Files/EndFileNewlineUnitTest.1.inc0000644000076500000240000000002313614652361027075 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/Files/EndFileNewlineUnitTest.5.inc0000644000076500000240000000005713614652361027110 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR2\Tests\Files; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class EndFileNewlineUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='') { switch ($testFile) { case 'EndFileNewlineUnitTest.1.inc': case 'EndFileNewlineUnitTest.3.inc': case 'EndFileNewlineUnitTest.6.inc': case 'EndFileNewlineUnitTest.7.inc': case 'EndFileNewlineUnitTest.9.inc': case 'EndFileNewlineUnitTest.10.inc': return [2 => 1]; default: return []; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getWarningList($testFile='') { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/Methods/FunctionCallSignatureUnitTest.inc0000644000076500000240000001016713614652361030724 0ustar gsherwoodstaffget('/hello/{name}', function ($name) use ($app) { return 'Hello '.$app->escape($name); }, array( '1', '2', '3', )); // error somefunction2($foo, $bar, [ // ... ], $baz); // ok somefunction3(// ... $foo, $bar, [ // ... ], $baz ); // ok somefunction4(' this should not give an error because it\'s actually one line call with multi-line string '); // ok somefunction5("hey, multi-line string with some extra args", $foo, 12); // error somefunction6(' but args in a new line are not ok… ', $foo ); $this->setFoo(true ? 1 : 2, false, array( 'value', 'more')); $this->setFoo('some' . 'long' . 'text', 'string'); foo(bar(), $a); foo();bar(); foo( true ); myFunction(<< function ($x) { return true; }, 'baz' => false ) ); $qux = array_filter( $quux, function ($x) { return $x; } ); $this->listeners[] = $events->getSharedManager()->attach( 'Zend\Mvc\Application', MvcEvent::EVENT_DISPATCH, [$this, 'selectLayout'], 100 ); // phpcs:set PSR2.Methods.FunctionCallSignature requiredSpacesBeforeClose 1 foo('Testing multiline text' ); foo('Testing multiline text: ' // . $text ); foo('Testing multiline text: ' /* . $text */ ); foo('Testing multiline text: ' /* . $text */ // . $other_text ); foo('Testing multiline text: ' /* . $text // . $text2 */ ); // phpcs:set PSR2.Methods.FunctionCallSignature requiredSpacesBeforeClose 0 foo('Testing multiline text' ); foo('Testing multiline text' ); foo('Testing multiline text' // hello ); foo('Testing multiline text' /* hello */ ); foo('Testing multiline text' // hello ); foo('Testing multiline text' /* hello */ ); $var = foo('Testing multiline' // hi ) + foo('Testing multiline' // hi ) ; class Test { public function getInstance() { return new static( 'arg', 'foo' ); } public function getSelf() { return new self( 'a', 'b', 'c' ); } } $x = $var('y', 'x'); $obj->{$x}(1, 2); (function ($a, $b) { return function ($c, $d) use ($a, $b) { echo $a, $b, $c, $d; }; })( 'a','b' )('c', 'd'); return trim(preg_replace_callback( // sprintf replaces IGNORED_CHARS multiple times: for %s as well as %1$s (argument numbering) // /[%s]*([^%1$s]+)/ results in /[IGNORED_CHARS]*([^IGNORED_CHARS]+)/ sprintf('/[%s]*([^%1$s]+)/', self::IGNORED_CHARS), function (array $term) use ($mode): string { // query pieces have to bigger than one char, otherwise they are too expensive for the search if (mb_strlen($term[1], 'UTF-8') > 1) { // in boolean search mode '' (empty) means OR, '-' means NOT return sprintf('%s%s ', $mode === 'AND' ? '+' : '', self::extractUmlauts($term[1])); } return ''; }, $search )); return trim(preg_replace_callback( // sprintf replaces IGNORED_CHARS multiple times: for %s as well as %1$s (argument numbering) // /[%s]*([^%1$s]+)/ results in /[IGNORED_CHARS]*([^IGNORED_CHARS]+)/ sprintf('/[%s]*([^%1$s]+)/', self::IGNORED_CHARS), function (array $term) use ($mode): string { // query pieces have to bigger than one char, otherwise they are too expensive for the search if (mb_strlen($term[1], 'UTF-8') > 1) { // in boolean search mode '' (empty) means OR, '-' means NOT return sprintf('%s%s ', $mode === 'AND' ? '+' : '', self::extractUmlauts($term[1])); } return ''; }, $search )); PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/Methods/FunctionCallSignatureUnitTest.inc.fixed0000644000076500000240000001016713614652361032022 0ustar gsherwoodstaffget('/hello/{name}', function ($name) use ($app) { return 'Hello '.$app->escape($name); }, array( '1', '2', '3', )); // error somefunction2( $foo, $bar, [ // ... ], $baz ); // ok somefunction3(// ... $foo, $bar, [ // ... ], $baz ); // ok somefunction4(' this should not give an error because it\'s actually one line call with multi-line string '); // ok somefunction5("hey, multi-line string with some extra args", $foo, 12); // error somefunction6( ' but args in a new line are not ok… ', $foo ); $this->setFoo(true ? 1 : 2, false, array( 'value', 'more')); $this->setFoo('some' . 'long' . 'text', 'string'); foo(bar(), $a); foo();bar(); foo( true ); myFunction(<< function ($x) { return true; }, 'baz' => false ) ); $qux = array_filter( $quux, function ($x) { return $x; } ); $this->listeners[] = $events->getSharedManager()->attach( 'Zend\Mvc\Application', MvcEvent::EVENT_DISPATCH, [$this, 'selectLayout'], 100 ); // phpcs:set PSR2.Methods.FunctionCallSignature requiredSpacesBeforeClose 1 foo('Testing multiline text' ); foo('Testing multiline text: ' ); // . $text foo('Testing multiline text: ' /* . $text */ ); foo('Testing multiline text: ' /* . $text */ ); // . $other_text foo('Testing multiline text: ' /* . $text // . $text2 */ ); // phpcs:set PSR2.Methods.FunctionCallSignature requiredSpacesBeforeClose 0 foo('Testing multiline text'); foo('Testing multiline text'); foo('Testing multiline text'); // hello foo('Testing multiline text' /* hello */); foo('Testing multiline text'); // hello foo('Testing multiline text' /* hello */); $var = foo('Testing multiline') // hi + foo('Testing multiline'); // hi class Test { public function getInstance() { return new static( 'arg', 'foo' ); } public function getSelf() { return new self( 'a', 'b', 'c' ); } } $x = $var( 'y', 'x' ); $obj->{$x}( 1, 2 ); (function ($a, $b) { return function ($c, $d) use ($a, $b) { echo $a, $b, $c, $d; }; })( 'a', 'b' )( 'c', 'd' ); return trim(preg_replace_callback( // sprintf replaces IGNORED_CHARS multiple times: for %s as well as %1$s (argument numbering) // /[%s]*([^%1$s]+)/ results in /[IGNORED_CHARS]*([^IGNORED_CHARS]+)/ sprintf('/[%s]*([^%1$s]+)/', self::IGNORED_CHARS), function (array $term) use ($mode): string { // query pieces have to bigger than one char, otherwise they are too expensive for the search if (mb_strlen($term[1], 'UTF-8') > 1) { // in boolean search mode '' (empty) means OR, '-' means NOT return sprintf('%s%s ', $mode === 'AND' ? '+' : '', self::extractUmlauts($term[1])); } return ''; }, $search )); return trim(preg_replace_callback( // sprintf replaces IGNORED_CHARS multiple times: for %s as well as %1$s (argument numbering) // /[%s]*([^%1$s]+)/ results in /[IGNORED_CHARS]*([^IGNORED_CHARS]+)/ sprintf('/[%s]*([^%1$s]+)/', self::IGNORED_CHARS), function (array $term) use ($mode): string { // query pieces have to bigger than one char, otherwise they are too expensive for the search if (mb_strlen($term[1], 'UTF-8') > 1) { // in boolean search mode '' (empty) means OR, '-' means NOT return sprintf('%s%s ', $mode === 'AND' ? '+' : '', self::extractUmlauts($term[1])); } return ''; }, $search )); PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/Methods/FunctionCallSignatureUnitTest.php0000644000076500000240000000407113614652361030737 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR2\Tests\Methods; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class FunctionCallSignatureUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 18 => 3, 21 => 1, 48 => 1, 87 => 1, 90 => 1, 91 => 1, 103 => 1, 111 => 1, 117 => 4, 121 => 1, 125 => 1, 129 => 1, 133 => 1, 138 => 1, 146 => 1, 150 => 1, 154 => 1, 158 => 1, 162 => 1, 167 => 1, 172 => 1, 175 => 1, 178 => 1, 186 => 1, 187 => 1, 194 => 3, 199 => 1, 200 => 2, 202 => 1, 203 => 1, 210 => 2, 211 => 1, 212 => 2, 217 => 1, 218 => 1, 227 => 1, 228 => 1, 233 => 1, 234 => 1, 242 => 1, 243 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/Methods/FunctionClosingBraceUnitTest.inc0000644000076500000240000000111113614652361030507 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR2\Tests\Methods; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class FunctionClosingBraceUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 16 => 1, 23 => 1, 40 => 1, 47 => 1, 63 => 1, 70 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/Methods/MethodDeclarationUnitTest.inc0000644000076500000240000000366413614652361030053 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR2\Tests\Methods; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class MethodDeclarationUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 9 => 1, 11 => 1, 13 => 1, 15 => 3, 24 => 1, 34 => 1, 36 => 1, 38 => 1, 40 => 3, 50 => 1, 52 => 1, 54 => 1, 56 => 3, 63 => 2, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return [ 5 => 1, 21 => 1, 30 => 1, 46 => 1, 63 => 1, ]; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/Namespaces/NamespaceDeclarationUnitTest.inc0000644000076500000240000000040313614652361031167 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR2\Tests\Namespaces; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class NamespaceDeclarationUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 6 => 1, 9 => 1, 17 => 1, 19 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/Namespaces/UseDeclarationUnitTest.1.inc0000644000076500000240000000100113614652361030161 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/Namespaces/UseDeclarationUnitTest.2.inc.fixed0000644000076500000240000000052013614652361031265 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/Namespaces/UseDeclarationUnitTest.3.inc0000644000076500000240000000030613614652361030172 0ustar gsherwoodstaff

    PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/Namespaces/UseDeclarationUnitTest.5.inc0000644000076500000240000000216213614652361030176 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/Namespaces/UseDeclarationUnitTest.7.inc0000644000076500000240000000004713614652361030200 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\PSR2\Tests\Namespaces; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class UseDeclarationUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='') { switch ($testFile) { case 'UseDeclarationUnitTest.2.inc': return [ 4 => 1, 5 => 1, 6 => 1, 7 => 1, 12 => 1, ]; case 'UseDeclarationUnitTest.3.inc': return [ 4 => 1, 6 => 1, ]; case 'UseDeclarationUnitTest.5.inc': return [ 5 => 1, 6 => 1, 8 => 1, 14 => 1, 17 => 1, 18 => 1, 19 => 1, 21 => 1, 28 => 1, 30 => 1, 35 => 1, ]; case 'UseDeclarationUnitTest.10.inc': case 'UseDeclarationUnitTest.11.inc': case 'UseDeclarationUnitTest.12.inc': case 'UseDeclarationUnitTest.13.inc': case 'UseDeclarationUnitTest.14.inc': case 'UseDeclarationUnitTest.16.inc': case 'UseDeclarationUnitTest.17.inc': return [2 => 1]; case 'UseDeclarationUnitTest.15.inc': return [ 3 => 1, 4 => 1, 5 => 1, ]; default: return []; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/PSR2/Tests/Namespaces/UseDeclarationUnitTest.8.inc0000644000076500000240000000007013614652361030175 0ustar gsherwoodstaff The PSR-2 coding standard. 0 0 0 0 0 0 0 0 0 0 0 0 PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Docs/Arrays/ArrayBracketSpacingStandard.xml0000644000076500000240000000105513614652361030355 0ustar gsherwoodstaff ['bar']; ]]> [ 'bar' ]; ]]> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Docs/Arrays/ArrayDeclarationStandard.xml0000644000076500000240000000616413614652361027730 0ustar gsherwoodstaff array keyword must be lowercase. ]]> array keyword. ]]> 'value1', 'key2' => 'value2', ); ]]> 'value1', 'key2' => 'value2', ); ]]> array keyword. The closing parenthesis must be aligned with the start of the array keyword. ]]> 'key1' => 'value1', 'key2' => 'value2', ); ]]> 'key1' => 'value1', 'key2' => 'value2', ); ]]> => 'ValueTen', 'keyTwenty' => 'ValueTwenty', ); ]]> => 'ValueTen', 'keyTwenty' => 'ValueTwenty', ); ]]> 'value1', 'key2' => 'value2', 'key3' => 'value3', ); ]]> 'value1', 'key2' => 'value2', 'key3' => 'value3' ); ]]> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Docs/Classes/LowercaseClassKeywordsStandard.xml0000644000076500000240000000114013614652361031267 0ustar gsherwoodstaff final class Foo extends Bar { } ]]> Final Class Foo Extends Bar { } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Docs/Classes/SelfMemberReferenceStandard.xml0000644000076500000240000000247213614652361030476 0ustar gsherwoodstaff self::foo(); ]]> SELF::foo(); ]]> ::foo(); ]]> :: foo(); ]]> self::bar(); } } ]]> Foo { public static function bar() { } public static function baz() { Foo::bar(); } } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Docs/Commenting/DocCommentAlignmentStandard.xml0000644000076500000240000000151513614652361031225 0ustar gsherwoodstaff * @see foo() */ ]]> * @see foo() */ ]]> @see foo() */ ]]> @see foo() */ ]]> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Docs/Commenting/FunctionCommentThrowTagStandard.xml0000644000076500000240000000120713614652361032124 0ustar gsherwoodstaff @throws Exception all the time * @return void */ function foo() { throw new Exception('Danger!'); } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Docs/ControlStructures/ForEachLoopDeclarationStandard.xml0000644000076500000240000000176113614652361033274 0ustar gsherwoodstaff $foo as $bar => $baz) { echo $baz; } ]]> $foo as $bar=>$baz ) { echo $baz; } ]]> as $bar => $baz) { echo $baz; } ]]> AS $bar => $baz) { echo $baz; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Docs/ControlStructures/ForLoopDeclarationStandard.xml0000644000076500000240000000253213614652361032510 0ustar gsherwoodstaff $i = 0; $i < 10; $i++) { echo $i; } ]]> $i = 0; $i < 10; $i++ ) { echo $i; } ]]> ; $i < 10; $i++) { echo $i; } ]]> ; $i < 10 ; $i++) { echo $i; } ]]> $i < 10; $i++) { echo $i; } ]]> $i < 10;$i++) { echo $i; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Docs/ControlStructures/LowercaseDeclarationStandard.xml0000644000076500000240000000104213614652361033047 0ustar gsherwoodstaff if ($foo) { $bar = true; } ]]> IF ($foo) { $bar = true; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Docs/Functions/FunctionDuplicateArgumentStandard.xml0000644000076500000240000000100513614652361032323 0ustar gsherwoodstaff isset($foo)) { echo $foo; } ]]> isSet($foo)) { echo $foo; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Docs/Functions/LowercaseFunctionKeywordsStandard.xml0000644000076500000240000000103613614652362032367 0ustar gsherwoodstaff function foo() { return true; } ]]> FUNCTION foo() { return true; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Docs/Scope/StaticThisUsageStandard.xml0000644000076500000240000000116413614652362027354 0ustar gsherwoodstaff static function bar() { return self::$staticMember; } } ]]> static function bar() { return $this->$staticMember; } } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Docs/Strings/EchoedStringsStandard.xml0000644000076500000240000000074513614652362027435 0ustar gsherwoodstaff "Hello"; ]]> ("Hello"); ]]> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Docs/WhiteSpace/CastSpacingStandard.xml0000644000076500000240000000073313614652362027473 0ustar gsherwoodstaff int)'42'; ]]> int )'42'; ]]> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Docs/WhiteSpace/FunctionOpeningBraceStandard.xml0000644000076500000240000000161213614652362031333 0ustar gsherwoodstaff { } ]]> { } ]]> return 42; } ]]> return 42; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Docs/WhiteSpace/LanguageConstructSpacingStandard.xml0000644000076500000240000000106213614652362032225 0ustar gsherwoodstaff "hi"; ]]> "hi"; ]]> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Docs/WhiteSpace/ObjectOperatorSpacingStandard.xml0000644000076500000240000000100113614652362031510 0ustar gsherwoodstaff ) should not have any space around it. ]]> ->bar(); ]]> -> bar(); ]]> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Docs/WhiteSpace/ScopeKeywordSpacingStandard.xml0000644000076500000240000000110013614652362031204 0ustar gsherwoodstaff static function foo() { } ]]> static function foo() { } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Docs/WhiteSpace/SemicolonSpacingStandard.xml0000644000076500000240000000067613614652362030537 0ustar gsherwoodstaff ; ]]> ; ]]> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Arrays/ArrayBracketSpacingSniff.php0000644000076500000240000000661713614652362030223 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Arrays; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class ArrayBracketSpacingSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_OPEN_SQUARE_BRACKET, T_CLOSE_SQUARE_BRACKET, ]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being checked. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (($tokens[$stackPtr]['code'] === T_OPEN_SQUARE_BRACKET && isset($tokens[$stackPtr]['bracket_closer']) === false) || ($tokens[$stackPtr]['code'] === T_CLOSE_SQUARE_BRACKET && isset($tokens[$stackPtr]['bracket_opener']) === false) ) { // Bow out for parse error/during live coding. return; } // Square brackets can not have a space before them. $prevType = $tokens[($stackPtr - 1)]['code']; if ($prevType === T_WHITESPACE) { $nonSpace = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 2), null, true); $expected = $tokens[$nonSpace]['content'].$tokens[$stackPtr]['content']; $found = $phpcsFile->getTokensAsString($nonSpace, ($stackPtr - $nonSpace)).$tokens[$stackPtr]['content']; $error = 'Space found before square bracket; expected "%s" but found "%s"'; $data = [ $expected, $found, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceBeforeBracket', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($stackPtr - 1), ''); } } // Open square brackets can't ever have spaces after them. if ($tokens[$stackPtr]['code'] === T_OPEN_SQUARE_BRACKET) { $nextType = $tokens[($stackPtr + 1)]['code']; if ($nextType === T_WHITESPACE) { $nonSpace = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 2), null, true); $expected = $tokens[$stackPtr]['content'].$tokens[$nonSpace]['content']; $found = $phpcsFile->getTokensAsString($stackPtr, ($nonSpace - $stackPtr + 1)); $error = 'Space found after square bracket; expected "%s" but found "%s"'; $data = [ $expected, $found, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceAfterBracket', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($stackPtr + 1), ''); } } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Arrays/ArrayDeclarationSniff.php0000644000076500000240000011321413614652362027560 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Arrays; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class ArrayDeclarationSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_ARRAY, T_OPEN_SHORT_ARRAY, ]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being checked. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if ($tokens[$stackPtr]['code'] === T_ARRAY) { $phpcsFile->recordMetric($stackPtr, 'Short array syntax used', 'no'); // Array keyword should be lower case. if ($tokens[$stackPtr]['content'] !== strtolower($tokens[$stackPtr]['content'])) { if ($tokens[$stackPtr]['content'] === strtoupper($tokens[$stackPtr]['content'])) { $phpcsFile->recordMetric($stackPtr, 'Array keyword case', 'upper'); } else { $phpcsFile->recordMetric($stackPtr, 'Array keyword case', 'mixed'); } $error = 'Array keyword should be lower case; expected "array" but found "%s"'; $data = [$tokens[$stackPtr]['content']]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NotLowerCase', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken($stackPtr, 'array'); } } else { $phpcsFile->recordMetric($stackPtr, 'Array keyword case', 'lower'); } $arrayStart = $tokens[$stackPtr]['parenthesis_opener']; if (isset($tokens[$arrayStart]['parenthesis_closer']) === false) { return; } $arrayEnd = $tokens[$arrayStart]['parenthesis_closer']; if ($arrayStart !== ($stackPtr + 1)) { $error = 'There must be no space between the "array" keyword and the opening parenthesis'; $next = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), $arrayStart, true); if (isset(Tokens::$commentTokens[$tokens[$next]['code']]) === true) { // We don't have anywhere to put the comment, so don't attempt to fix it. $phpcsFile->addError($error, $stackPtr, 'SpaceAfterKeyword'); } else { $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceAfterKeyword'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($stackPtr + 1); $i < $arrayStart; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } } } } else { $phpcsFile->recordMetric($stackPtr, 'Short array syntax used', 'yes'); $arrayStart = $stackPtr; $arrayEnd = $tokens[$stackPtr]['bracket_closer']; }//end if // Check for empty arrays. $content = $phpcsFile->findNext(T_WHITESPACE, ($arrayStart + 1), ($arrayEnd + 1), true); if ($content === $arrayEnd) { // Empty array, but if the brackets aren't together, there's a problem. if (($arrayEnd - $arrayStart) !== 1) { $error = 'Empty array declaration must have no space between the parentheses'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceInEmptyArray'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($arrayStart + 1); $i < $arrayEnd; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } } // We can return here because there is nothing else to check. All code // below can assume that the array is not empty. return; } if ($tokens[$arrayStart]['line'] === $tokens[$arrayEnd]['line']) { $this->processSingleLineArray($phpcsFile, $stackPtr, $arrayStart, $arrayEnd); } else { $this->processMultiLineArray($phpcsFile, $stackPtr, $arrayStart, $arrayEnd); } }//end process() /** * Processes a single-line array definition. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being checked. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param int $arrayStart The token that starts the array definition. * @param int $arrayEnd The token that ends the array definition. * * @return void */ public function processSingleLineArray($phpcsFile, $stackPtr, $arrayStart, $arrayEnd) { $tokens = $phpcsFile->getTokens(); // Check if there are multiple values. If so, then it has to be multiple lines // unless it is contained inside a function call or condition. $valueCount = 0; $commas = []; for ($i = ($arrayStart + 1); $i < $arrayEnd; $i++) { // Skip bracketed statements, like function calls. if ($tokens[$i]['code'] === T_OPEN_PARENTHESIS) { $i = $tokens[$i]['parenthesis_closer']; continue; } if ($tokens[$i]['code'] === T_COMMA) { // Before counting this comma, make sure we are not // at the end of the array. $next = $phpcsFile->findNext(T_WHITESPACE, ($i + 1), $arrayEnd, true); if ($next !== false) { $valueCount++; $commas[] = $i; } else { // There is a comma at the end of a single line array. $error = 'Comma not allowed after last value in single-line array declaration'; $fix = $phpcsFile->addFixableError($error, $i, 'CommaAfterLast'); if ($fix === true) { $phpcsFile->fixer->replaceToken($i, ''); } } } }//end for // Now check each of the double arrows (if any). $nextArrow = $arrayStart; while (($nextArrow = $phpcsFile->findNext(T_DOUBLE_ARROW, ($nextArrow + 1), $arrayEnd)) !== false) { if ($tokens[($nextArrow - 1)]['code'] !== T_WHITESPACE) { $content = $tokens[($nextArrow - 1)]['content']; $error = 'Expected 1 space between "%s" and double arrow; 0 found'; $data = [$content]; $fix = $phpcsFile->addFixableError($error, $nextArrow, 'NoSpaceBeforeDoubleArrow', $data); if ($fix === true) { $phpcsFile->fixer->addContentBefore($nextArrow, ' '); } } else { $spaceLength = $tokens[($nextArrow - 1)]['length']; if ($spaceLength !== 1) { $content = $tokens[($nextArrow - 2)]['content']; $error = 'Expected 1 space between "%s" and double arrow; %s found'; $data = [ $content, $spaceLength, ]; $fix = $phpcsFile->addFixableError($error, $nextArrow, 'SpaceBeforeDoubleArrow', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($nextArrow - 1), ' '); } } }//end if if ($tokens[($nextArrow + 1)]['code'] !== T_WHITESPACE) { $content = $tokens[($nextArrow + 1)]['content']; $error = 'Expected 1 space between double arrow and "%s"; 0 found'; $data = [$content]; $fix = $phpcsFile->addFixableError($error, $nextArrow, 'NoSpaceAfterDoubleArrow', $data); if ($fix === true) { $phpcsFile->fixer->addContent($nextArrow, ' '); } } else { $spaceLength = $tokens[($nextArrow + 1)]['length']; if ($spaceLength !== 1) { $content = $tokens[($nextArrow + 2)]['content']; $error = 'Expected 1 space between double arrow and "%s"; %s found'; $data = [ $content, $spaceLength, ]; $fix = $phpcsFile->addFixableError($error, $nextArrow, 'SpaceAfterDoubleArrow', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($nextArrow + 1), ' '); } } }//end if }//end while if ($valueCount > 0) { $nestedParenthesis = false; if (isset($tokens[$stackPtr]['nested_parenthesis']) === true) { $nested = $tokens[$stackPtr]['nested_parenthesis']; $nestedParenthesis = array_pop($nested); } if ($nestedParenthesis === false || $tokens[$nestedParenthesis]['line'] !== $tokens[$stackPtr]['line'] ) { $error = 'Array with multiple values cannot be declared on a single line'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SingleLineNotAllowed'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->addNewline($arrayStart); $phpcsFile->fixer->addNewlineBefore($arrayEnd); $phpcsFile->fixer->endChangeset(); } return; } // We have a multiple value array that is inside a condition or // function. Check its spacing is correct. foreach ($commas as $comma) { if ($tokens[($comma + 1)]['code'] !== T_WHITESPACE) { $content = $tokens[($comma + 1)]['content']; $error = 'Expected 1 space between comma and "%s"; 0 found'; $data = [$content]; $fix = $phpcsFile->addFixableError($error, $comma, 'NoSpaceAfterComma', $data); if ($fix === true) { $phpcsFile->fixer->addContent($comma, ' '); } } else { $spaceLength = $tokens[($comma + 1)]['length']; if ($spaceLength !== 1) { $content = $tokens[($comma + 2)]['content']; $error = 'Expected 1 space between comma and "%s"; %s found'; $data = [ $content, $spaceLength, ]; $fix = $phpcsFile->addFixableError($error, $comma, 'SpaceAfterComma', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($comma + 1), ' '); } } }//end if if ($tokens[($comma - 1)]['code'] === T_WHITESPACE) { $content = $tokens[($comma - 2)]['content']; $spaceLength = $tokens[($comma - 1)]['length']; $error = 'Expected 0 spaces between "%s" and comma; %s found'; $data = [ $content, $spaceLength, ]; $fix = $phpcsFile->addFixableError($error, $comma, 'SpaceBeforeComma', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($comma - 1), ''); } } }//end foreach }//end if }//end processSingleLineArray() /** * Processes a multi-line array definition. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being checked. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param int $arrayStart The token that starts the array definition. * @param int $arrayEnd The token that ends the array definition. * * @return void */ public function processMultiLineArray($phpcsFile, $stackPtr, $arrayStart, $arrayEnd) { $tokens = $phpcsFile->getTokens(); $keywordStart = $tokens[$stackPtr]['column']; // Check the closing bracket is on a new line. $lastContent = $phpcsFile->findPrevious(T_WHITESPACE, ($arrayEnd - 1), $arrayStart, true); if ($tokens[$lastContent]['line'] === $tokens[$arrayEnd]['line']) { $error = 'Closing parenthesis of array declaration must be on a new line'; $fix = $phpcsFile->addFixableError($error, $arrayEnd, 'CloseBraceNewLine'); if ($fix === true) { $phpcsFile->fixer->addNewlineBefore($arrayEnd); } } else if ($tokens[$arrayEnd]['column'] !== $keywordStart) { // Check the closing bracket is lined up under the "a" in array. $expected = ($keywordStart - 1); $found = ($tokens[$arrayEnd]['column'] - 1); $error = 'Closing parenthesis not aligned correctly; expected %s space(s) but found %s'; $data = [ $expected, $found, ]; $fix = $phpcsFile->addFixableError($error, $arrayEnd, 'CloseBraceNotAligned', $data); if ($fix === true) { if ($found === 0) { $phpcsFile->fixer->addContent(($arrayEnd - 1), str_repeat(' ', $expected)); } else { $phpcsFile->fixer->replaceToken(($arrayEnd - 1), str_repeat(' ', $expected)); } } }//end if $keyUsed = false; $singleUsed = false; $indices = []; $maxLength = 0; if ($tokens[$stackPtr]['code'] === T_ARRAY) { $lastToken = $tokens[$stackPtr]['parenthesis_opener']; } else { $lastToken = $stackPtr; } // Find all the double arrows that reside in this scope. for ($nextToken = ($stackPtr + 1); $nextToken < $arrayEnd; $nextToken++) { // Skip bracketed statements, like function calls. if ($tokens[$nextToken]['code'] === T_OPEN_PARENTHESIS && (isset($tokens[$nextToken]['parenthesis_owner']) === false || $tokens[$nextToken]['parenthesis_owner'] !== $stackPtr) ) { $nextToken = $tokens[$nextToken]['parenthesis_closer']; continue; } if ($tokens[$nextToken]['code'] === T_ARRAY || $tokens[$nextToken]['code'] === T_OPEN_SHORT_ARRAY || $tokens[$nextToken]['code'] === T_CLOSURE || $tokens[$nextToken]['code'] === T_FN ) { // Let subsequent calls of this test handle nested arrays. if ($tokens[$lastToken]['code'] !== T_DOUBLE_ARROW) { $indices[] = ['value' => $nextToken]; $lastToken = $nextToken; } if ($tokens[$nextToken]['code'] === T_ARRAY) { $nextToken = $tokens[$tokens[$nextToken]['parenthesis_opener']]['parenthesis_closer']; } else if ($tokens[$nextToken]['code'] === T_OPEN_SHORT_ARRAY) { $nextToken = $tokens[$nextToken]['bracket_closer']; } else { // T_CLOSURE. $nextToken = $tokens[$nextToken]['scope_closer']; } $nextToken = $phpcsFile->findNext(T_WHITESPACE, ($nextToken + 1), null, true); if ($tokens[$nextToken]['code'] !== T_COMMA) { $nextToken--; } else { $lastToken = $nextToken; } continue; }//end if if ($tokens[$nextToken]['code'] !== T_DOUBLE_ARROW && $tokens[$nextToken]['code'] !== T_COMMA ) { continue; } $currentEntry = []; if ($tokens[$nextToken]['code'] === T_COMMA) { $stackPtrCount = 0; if (isset($tokens[$stackPtr]['nested_parenthesis']) === true) { $stackPtrCount = count($tokens[$stackPtr]['nested_parenthesis']); } $commaCount = 0; if (isset($tokens[$nextToken]['nested_parenthesis']) === true) { $commaCount = count($tokens[$nextToken]['nested_parenthesis']); if ($tokens[$stackPtr]['code'] === T_ARRAY) { // Remove parenthesis that are used to define the array. $commaCount--; } } if ($commaCount > $stackPtrCount) { // This comma is inside more parenthesis than the ARRAY keyword, // then there it is actually a comma used to separate arguments // in a function call. continue; } if ($keyUsed === true && $tokens[$lastToken]['code'] === T_COMMA) { $error = 'No key specified for array entry; first entry specifies key'; $phpcsFile->addError($error, $nextToken, 'NoKeySpecified'); return; } if ($keyUsed === false) { if ($tokens[($nextToken - 1)]['code'] === T_WHITESPACE) { $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($nextToken - 1), null, true); if (($tokens[$prev]['code'] !== T_END_HEREDOC && $tokens[$prev]['code'] !== T_END_NOWDOC) || $tokens[($nextToken - 1)]['line'] === $tokens[$nextToken]['line'] ) { $content = $tokens[($nextToken - 2)]['content']; if ($tokens[($nextToken - 1)]['content'] === $phpcsFile->eolChar) { $spaceLength = 'newline'; } else { $spaceLength = $tokens[($nextToken - 1)]['length']; } $error = 'Expected 0 spaces before comma; %s found'; $data = [$spaceLength]; $fix = $phpcsFile->addFixableError($error, $nextToken, 'SpaceBeforeComma', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($nextToken - 1), ''); } } }//end if $valueContent = $phpcsFile->findNext( Tokens::$emptyTokens, ($lastToken + 1), $nextToken, true ); $indices[] = ['value' => $valueContent]; $singleUsed = true; }//end if $lastToken = $nextToken; continue; }//end if if ($tokens[$nextToken]['code'] === T_DOUBLE_ARROW) { if ($singleUsed === true) { $error = 'Key specified for array entry; first entry has no key'; $phpcsFile->addError($error, $nextToken, 'KeySpecified'); return; } $currentEntry['arrow'] = $nextToken; $keyUsed = true; // Find the start of index that uses this double arrow. $indexEnd = $phpcsFile->findPrevious(T_WHITESPACE, ($nextToken - 1), $arrayStart, true); $indexStart = $phpcsFile->findStartOfStatement($indexEnd); if ($indexStart === $indexEnd) { $currentEntry['index'] = $indexEnd; $currentEntry['index_content'] = $tokens[$indexEnd]['content']; $currentEntry['index_length'] = $tokens[$indexEnd]['length']; } else { $currentEntry['index'] = $indexStart; $currentEntry['index_content'] = ''; $currentEntry['index_length'] = 0; for ($i = $indexStart; $i <= $indexEnd; $i++) { $currentEntry['index_content'] .= $tokens[$i]['content']; $currentEntry['index_length'] += $tokens[$i]['length']; } } if ($maxLength < $currentEntry['index_length']) { $maxLength = $currentEntry['index_length']; } // Find the value of this index. $nextContent = $phpcsFile->findNext( Tokens::$emptyTokens, ($nextToken + 1), $arrayEnd, true ); $currentEntry['value'] = $nextContent; $indices[] = $currentEntry; $lastToken = $nextToken; }//end if }//end for // Check for multi-line arrays that should be single-line. $singleValue = false; if (empty($indices) === true) { $singleValue = true; } else if (count($indices) === 1 && $tokens[$lastToken]['code'] === T_COMMA) { // There may be another array value without a comma. $exclude = Tokens::$emptyTokens; $exclude[] = T_COMMA; $nextContent = $phpcsFile->findNext($exclude, ($indices[0]['value'] + 1), $arrayEnd, true); if ($nextContent === false) { $singleValue = true; } } if ($singleValue === true) { // Before we complain, make sure the single value isn't a here/nowdoc. $next = $phpcsFile->findNext(Tokens::$heredocTokens, ($arrayStart + 1), ($arrayEnd - 1)); if ($next === false) { // Array cannot be empty, so this is a multi-line array with // a single value. It should be defined on single line. $error = 'Multi-line array contains a single value; use single-line array instead'; $errorCode = 'MultiLineNotAllowed'; $find = Tokens::$phpcsCommentTokens; $find[] = T_COMMENT; $comment = $phpcsFile->findNext($find, ($arrayStart + 1), $arrayEnd); if ($comment === false) { $fix = $phpcsFile->addFixableError($error, $stackPtr, $errorCode); } else { $fix = false; $phpcsFile->addError($error, $stackPtr, $errorCode); } if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($arrayStart + 1); $i < $arrayEnd; $i++) { if ($tokens[$i]['code'] !== T_WHITESPACE) { break; } $phpcsFile->fixer->replaceToken($i, ''); } for ($i = ($arrayEnd - 1); $i > $arrayStart; $i--) { if ($tokens[$i]['code'] !== T_WHITESPACE) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } return; }//end if }//end if /* This section checks for arrays that don't specify keys. Arrays such as: array( 'aaa', 'bbb', 'd', ); */ if ($keyUsed === false && empty($indices) === false) { $count = count($indices); $lastIndex = $indices[($count - 1)]['value']; $trailingContent = $phpcsFile->findPrevious( Tokens::$emptyTokens, ($arrayEnd - 1), $lastIndex, true ); if ($tokens[$trailingContent]['code'] !== T_COMMA) { $phpcsFile->recordMetric($stackPtr, 'Array end comma', 'no'); $error = 'Comma required after last value in array declaration'; $fix = $phpcsFile->addFixableError($error, $trailingContent, 'NoCommaAfterLast'); if ($fix === true) { $phpcsFile->fixer->addContent($trailingContent, ','); } } else { $phpcsFile->recordMetric($stackPtr, 'Array end comma', 'yes'); } $lastValueLine = false; foreach ($indices as $value) { if (empty($value['value']) === true) { // Array was malformed and we couldn't figure out // the array value correctly, so we have to ignore it. // Other parts of this sniff will correct the error. continue; } if ($lastValueLine !== false && $tokens[$value['value']]['line'] === $lastValueLine) { $error = 'Each value in a multi-line array must be on a new line'; $fix = $phpcsFile->addFixableError($error, $value['value'], 'ValueNoNewline'); if ($fix === true) { if ($tokens[($value['value'] - 1)]['code'] === T_WHITESPACE) { $phpcsFile->fixer->replaceToken(($value['value'] - 1), ''); } $phpcsFile->fixer->addNewlineBefore($value['value']); } } else if ($tokens[($value['value'] - 1)]['code'] === T_WHITESPACE) { $expected = $keywordStart; $first = $phpcsFile->findFirstOnLine(T_WHITESPACE, $value['value'], true); $found = ($tokens[$first]['column'] - 1); if ($found !== $expected) { $error = 'Array value not aligned correctly; expected %s spaces but found %s'; $data = [ $expected, $found, ]; $fix = $phpcsFile->addFixableError($error, $value['value'], 'ValueNotAligned', $data); if ($fix === true) { if ($found === 0) { $phpcsFile->fixer->addContent(($value['value'] - 1), str_repeat(' ', $expected)); } else { $phpcsFile->fixer->replaceToken(($value['value'] - 1), str_repeat(' ', $expected)); } } } }//end if $lastValueLine = $tokens[$value['value']]['line']; }//end foreach }//end if /* Below the actual indentation of the array is checked. Errors will be thrown when a key is not aligned, when a double arrow is not aligned, and when a value is not aligned correctly. If an error is found in one of the above areas, then errors are not reported for the rest of the line to avoid reporting spaces and columns incorrectly. Often fixing the first problem will fix the other 2 anyway. For example: $a = array( 'index' => '2', ); or $a = [ 'index' => '2', ]; In this array, the double arrow is indented too far, but this will also cause an error in the value's alignment. If the arrow were to be moved back one space however, then both errors would be fixed. */ $numValues = count($indices); $indicesStart = ($keywordStart + 1); $indexLine = $tokens[$stackPtr]['line']; $lastIndexLine = null; foreach ($indices as $index) { if ($index['value'] === false) { // Syntax error or live coding. continue; } if (isset($index['index']) === false) { // Array value only. if ($tokens[$index['value']]['line'] === $tokens[$stackPtr]['line'] && $numValues > 1) { $error = 'The first value in a multi-value array must be on a new line'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'FirstValueNoNewline'); if ($fix === true) { $phpcsFile->fixer->addNewlineBefore($index['value']); } } continue; } $lastIndexLine = $indexLine; $indexLine = $tokens[$index['index']]['line']; if ($indexLine === $tokens[$stackPtr]['line']) { $error = 'The first index in a multi-value array must be on a new line'; $fix = $phpcsFile->addFixableError($error, $index['index'], 'FirstIndexNoNewline'); if ($fix === true) { $phpcsFile->fixer->addNewlineBefore($index['index']); } continue; } if ($indexLine === $lastIndexLine) { $error = 'Each index in a multi-line array must be on a new line'; $fix = $phpcsFile->addFixableError($error, $index['index'], 'IndexNoNewline'); if ($fix === true) { if ($tokens[($index['index'] - 1)]['code'] === T_WHITESPACE) { $phpcsFile->fixer->replaceToken(($index['index'] - 1), ''); } $phpcsFile->fixer->addNewlineBefore($index['index']); } continue; } if ($tokens[$index['index']]['column'] !== $indicesStart && ($index['index'] - 1) !== $arrayStart ) { $expected = ($indicesStart - 1); $found = ($tokens[$index['index']]['column'] - 1); $error = 'Array key not aligned correctly; expected %s spaces but found %s'; $data = [ $expected, $found, ]; $fix = $phpcsFile->addFixableError($error, $index['index'], 'KeyNotAligned', $data); if ($fix === true) { if ($found === 0 || $tokens[($index['index'] - 1)]['code'] !== T_WHITESPACE) { $phpcsFile->fixer->addContent(($index['index'] - 1), str_repeat(' ', $expected)); } else { $phpcsFile->fixer->replaceToken(($index['index'] - 1), str_repeat(' ', $expected)); } } } $arrowStart = ($tokens[$index['index']]['column'] + $maxLength + 1); if ($tokens[$index['arrow']]['column'] !== $arrowStart) { $expected = ($arrowStart - ($index['index_length'] + $tokens[$index['index']]['column'])); $found = ($tokens[$index['arrow']]['column'] - ($index['index_length'] + $tokens[$index['index']]['column'])); $error = 'Array double arrow not aligned correctly; expected %s space(s) but found %s'; $data = [ $expected, $found, ]; $fix = $phpcsFile->addFixableError($error, $index['arrow'], 'DoubleArrowNotAligned', $data); if ($fix === true) { if ($found === 0) { $phpcsFile->fixer->addContent(($index['arrow'] - 1), str_repeat(' ', $expected)); } else { $phpcsFile->fixer->replaceToken(($index['arrow'] - 1), str_repeat(' ', $expected)); } } continue; } $valueStart = ($arrowStart + 3); if ($tokens[$index['value']]['column'] !== $valueStart) { $expected = ($valueStart - ($tokens[$index['arrow']]['length'] + $tokens[$index['arrow']]['column'])); $found = ($tokens[$index['value']]['column'] - ($tokens[$index['arrow']]['length'] + $tokens[$index['arrow']]['column'])); if ($found < 0) { $found = 'newline'; } $error = 'Array value not aligned correctly; expected %s space(s) but found %s'; $data = [ $expected, $found, ]; $fix = $phpcsFile->addFixableError($error, $index['arrow'], 'ValueNotAligned', $data); if ($fix === true) { if ($found === 'newline') { $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($index['value'] - 1), null, true); $phpcsFile->fixer->beginChangeset(); for ($i = ($prev + 1); $i < $index['value']; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->replaceToken(($index['value'] - 1), str_repeat(' ', $expected)); $phpcsFile->fixer->endChangeset(); } else if ($found === 0) { $phpcsFile->fixer->addContent(($index['value'] - 1), str_repeat(' ', $expected)); } else { $phpcsFile->fixer->replaceToken(($index['value'] - 1), str_repeat(' ', $expected)); } } }//end if // Check each line ends in a comma. $valueStart = $index['value']; $valueLine = $tokens[$index['value']]['line']; $nextComma = false; $end = $phpcsFile->findEndOfStatement($valueStart); if ($end === false) { $valueEnd = $valueStart; } else if ($tokens[$end]['code'] === T_COMMA) { $valueEnd = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($end - 1), $valueStart, true); $nextComma = $end; } else { $valueEnd = $end; $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($end + 1), $arrayEnd, true); if ($next !== false && $tokens[$next]['code'] === T_COMMA) { $nextComma = $next; } } $valueLine = $tokens[$valueEnd]['line']; if ($tokens[$valueEnd]['code'] === T_END_HEREDOC || $tokens[$valueEnd]['code'] === T_END_NOWDOC) { $valueLine++; } if ($nextComma === false || ($tokens[$nextComma]['line'] !== $valueLine)) { $error = 'Each line in an array declaration must end in a comma'; $fix = $phpcsFile->addFixableError($error, $index['value'], 'NoComma'); if ($fix === true) { // Find the end of the line and put a comma there. for ($i = ($index['value'] + 1); $i <= $arrayEnd; $i++) { if ($tokens[$i]['line'] > $valueLine) { break; } } $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->addContentBefore(($i - 1), ','); if ($nextComma !== false) { $phpcsFile->fixer->replaceToken($nextComma, ''); } $phpcsFile->fixer->endChangeset(); } }//end if // Check that there is no space before the comma. if ($nextComma !== false && $tokens[($nextComma - 1)]['code'] === T_WHITESPACE) { // Here/nowdoc closing tags must have the comma on the next line. $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($nextComma - 1), null, true); if ($tokens[$prev]['code'] !== T_END_HEREDOC && $tokens[$prev]['code'] !== T_END_NOWDOC) { $content = $tokens[($nextComma - 2)]['content']; $spaceLength = $tokens[($nextComma - 1)]['length']; $error = 'Expected 0 spaces between "%s" and comma; %s found'; $data = [ $content, $spaceLength, ]; $fix = $phpcsFile->addFixableError($error, $nextComma, 'SpaceBeforeComma', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($nextComma - 1), ''); } } } }//end foreach }//end processMultiLineArray() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Classes/ClassDeclarationSniff.php0000644000076500000240000002040713614652362027704 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Classes; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Standards\PSR2\Sniffs\Classes\ClassDeclarationSniff as PSR2ClassDeclarationSniff; use PHP_CodeSniffer\Util\Tokens; class ClassDeclarationSniff extends PSR2ClassDeclarationSniff { /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { // We want all the errors from the PSR2 standard, plus some of our own. parent::process($phpcsFile, $stackPtr); // Check that this is the only class or interface in the file. $nextClass = $phpcsFile->findNext([T_CLASS, T_INTERFACE], ($stackPtr + 1)); if ($nextClass !== false) { // We have another, so an error is thrown. $error = 'Only one interface or class is allowed in a file'; $phpcsFile->addError($error, $nextClass, 'MultipleClasses'); } }//end process() /** * Processes the opening section of a class declaration. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function processOpen(File $phpcsFile, $stackPtr) { parent::processOpen($phpcsFile, $stackPtr); $tokens = $phpcsFile->getTokens(); if ($tokens[($stackPtr - 1)]['code'] === T_WHITESPACE) { $prevContent = $tokens[($stackPtr - 1)]['content']; if ($prevContent !== $phpcsFile->eolChar) { $blankSpace = substr($prevContent, strpos($prevContent, $phpcsFile->eolChar)); $spaces = strlen($blankSpace); if ($tokens[($stackPtr - 2)]['code'] !== T_ABSTRACT && $tokens[($stackPtr - 2)]['code'] !== T_FINAL ) { if ($spaces !== 0) { $type = strtolower($tokens[$stackPtr]['content']); $error = 'Expected 0 spaces before %s keyword; %s found'; $data = [ $type, $spaces, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceBeforeKeyword', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($stackPtr - 1), ''); } } } }//end if }//end if }//end processOpen() /** * Processes the closing section of a class declaration. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function processClose(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['scope_closer']) === false) { return; } $closeBrace = $tokens[$stackPtr]['scope_closer']; // Check that the closing brace has one blank line after it. for ($nextContent = ($closeBrace + 1); $nextContent < $phpcsFile->numTokens; $nextContent++) { // Ignore comments on the same line as the brace. if ($tokens[$nextContent]['line'] === $tokens[$closeBrace]['line'] && ($tokens[$nextContent]['code'] === T_WHITESPACE || $tokens[$nextContent]['code'] === T_COMMENT || isset(Tokens::$phpcsCommentTokens[$tokens[$nextContent]['code']]) === true) ) { continue; } if ($tokens[$nextContent]['code'] !== T_WHITESPACE) { break; } } if ($nextContent === $phpcsFile->numTokens) { // Ignore the line check as this is the very end of the file. $difference = 1; } else { $difference = ($tokens[$nextContent]['line'] - $tokens[$closeBrace]['line'] - 1); } $lastContent = $phpcsFile->findPrevious(T_WHITESPACE, ($closeBrace - 1), $stackPtr, true); if ($difference === -1 || $tokens[$lastContent]['line'] === $tokens[$closeBrace]['line'] ) { $error = 'Closing %s brace must be on a line by itself'; $data = [$tokens[$stackPtr]['content']]; $fix = $phpcsFile->addFixableError($error, $closeBrace, 'CloseBraceSameLine', $data); if ($fix === true) { if ($difference === -1) { $phpcsFile->fixer->addNewlineBefore($nextContent); } if ($tokens[$lastContent]['line'] === $tokens[$closeBrace]['line']) { $phpcsFile->fixer->addNewlineBefore($closeBrace); } } } else if ($tokens[($closeBrace - 1)]['code'] === T_WHITESPACE) { $prevContent = $tokens[($closeBrace - 1)]['content']; if ($prevContent !== $phpcsFile->eolChar) { $blankSpace = substr($prevContent, strpos($prevContent, $phpcsFile->eolChar)); $spaces = strlen($blankSpace); if ($spaces !== 0) { if ($tokens[($closeBrace - 1)]['line'] !== $tokens[$closeBrace]['line']) { $error = 'Expected 0 spaces before closing brace; newline found'; $phpcsFile->addError($error, $closeBrace, 'NewLineBeforeCloseBrace'); } else { $error = 'Expected 0 spaces before closing brace; %s found'; $data = [$spaces]; $fix = $phpcsFile->addFixableError($error, $closeBrace, 'SpaceBeforeCloseBrace', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($closeBrace - 1), ''); } } } } }//end if if ($difference !== -1 && $difference !== 1) { if ($tokens[$nextContent]['code'] === T_DOC_COMMENT_OPEN_TAG) { $next = $phpcsFile->findNext(T_WHITESPACE, ($tokens[$nextContent]['comment_closer'] + 1), null, true); if ($next !== false && $tokens[$next]['code'] === T_FUNCTION) { return; } } $error = 'Closing brace of a %s must be followed by a single blank line; found %s'; $data = [ $tokens[$stackPtr]['content'], $difference, ]; $fix = $phpcsFile->addFixableError($error, $closeBrace, 'NewlinesAfterCloseBrace', $data); if ($fix === true) { if ($difference === 0) { $first = $phpcsFile->findFirstOnLine([], $nextContent, true); $phpcsFile->fixer->addNewlineBefore($first); } else { $phpcsFile->fixer->beginChangeset(); for ($i = ($closeBrace + 1); $i < $nextContent; $i++) { if ($tokens[$i]['line'] <= ($tokens[$closeBrace]['line'] + 1)) { continue; } else if ($tokens[$i]['line'] === $tokens[$nextContent]['line']) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } } }//end if }//end processClose() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Classes/ClassFileNameSniff.php0000644000076500000240000000365313614652362027143 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Classes; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class ClassFileNameSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_CLASS, T_INTERFACE, T_TRAIT, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $fullPath = basename($phpcsFile->getFilename()); $fileName = substr($fullPath, 0, strrpos($fullPath, '.')); if ($fileName === '') { // No filename probably means STDIN, so we can't do this check. return; } $tokens = $phpcsFile->getTokens(); $decName = $phpcsFile->findNext(T_STRING, $stackPtr); if ($tokens[$decName]['content'] !== $fileName) { $error = '%s name doesn\'t match filename; expected "%s %s"'; $data = [ ucfirst($tokens[$stackPtr]['content']), $tokens[$stackPtr]['content'], $fileName, ]; $phpcsFile->addError($error, $stackPtr, 'NoMatch', $data); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Classes/DuplicatePropertySniff.php0000644000076500000240000000463113614652362030151 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Classes; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class DuplicatePropertySniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['JS']; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_OBJECT]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being processed. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $properties = []; $wantedTokens = [ T_PROPERTY, T_OBJECT, ]; $next = $phpcsFile->findNext($wantedTokens, ($stackPtr + 1), $tokens[$stackPtr]['bracket_closer']); while ($next !== false && $next < $tokens[$stackPtr]['bracket_closer']) { if ($tokens[$next]['code'] === T_OBJECT) { // Skip nested objects. $next = $tokens[$next]['bracket_closer']; } else { $propName = $tokens[$next]['content']; if (isset($properties[$propName]) === true) { $error = 'Duplicate property definition found for "%s"; previously defined on line %s'; $data = [ $propName, $tokens[$properties[$propName]]['line'], ]; $phpcsFile->addError($error, $next, 'Found', $data); } $properties[$propName] = $next; }//end if $next = $phpcsFile->findNext($wantedTokens, ($next + 1), $tokens[$stackPtr]['bracket_closer']); }//end while }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Classes/LowercaseClassKeywordsSniff.php0000644000076500000240000000370513614652362031135 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Classes; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class LowercaseClassKeywordsSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { $targets = Tokens::$ooScopeTokens; $targets[] = T_EXTENDS; $targets[] = T_IMPLEMENTS; $targets[] = T_ABSTRACT; $targets[] = T_FINAL; $targets[] = T_VAR; $targets[] = T_CONST; return $targets; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $content = $tokens[$stackPtr]['content']; $contentLc = strtolower($content); if ($content !== $contentLc) { $error = '%s keyword must be lowercase; expected "%s" but found "%s"'; $data = [ strtoupper($content), $contentLc, $content, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'FoundUppercase', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken($stackPtr, $contentLc); } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Classes/SelfMemberReferenceSniff.php0000644000076500000240000002167613614652362030342 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Classes; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\AbstractScopeSniff; use PHP_CodeSniffer\Util\Tokens; class SelfMemberReferenceSniff extends AbstractScopeSniff { /** * Constructs a Squiz_Sniffs_Classes_SelfMemberReferenceSniff. */ public function __construct() { parent::__construct([T_CLASS], [T_DOUBLE_COLON]); }//end __construct() /** * Processes the function tokens within the class. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param int $stackPtr The position where the token was found. * @param int $currScope The current scope opener token. * * @return void */ protected function processTokenWithinScope(File $phpcsFile, $stackPtr, $currScope) { $tokens = $phpcsFile->getTokens(); // Determine if this is a double colon which needs to be examined. $conditions = $tokens[$stackPtr]['conditions']; $conditions = array_reverse($conditions, true); foreach ($conditions as $conditionToken => $tokenCode) { if ($tokenCode === T_CLASS || $tokenCode === T_ANON_CLASS || $tokenCode === T_CLOSURE) { break; } } if ($conditionToken !== $currScope) { return; } $calledClassName = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); if ($calledClassName === false) { // Parse error. return; } if ($tokens[$calledClassName]['code'] === T_SELF) { if ($tokens[$calledClassName]['content'] !== 'self') { $error = 'Must use "self::" for local static member reference; found "%s::"'; $data = [$tokens[$calledClassName]['content']]; $fix = $phpcsFile->addFixableError($error, $calledClassName, 'IncorrectCase', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken($calledClassName, 'self'); } return; } } else if ($tokens[$calledClassName]['code'] === T_STRING) { // If the class is called with a namespace prefix, build fully qualified // namespace calls for both current scope class and requested class. $prevNonEmpty = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($calledClassName - 1), null, true); if ($prevNonEmpty !== false && $tokens[$prevNonEmpty]['code'] === T_NS_SEPARATOR) { $declarationName = $this->getDeclarationNameWithNamespace($tokens, $calledClassName); $declarationName = ltrim($declarationName, '\\'); $fullQualifiedClassName = $this->getNamespaceOfScope($phpcsFile, $currScope); if ($fullQualifiedClassName === '\\') { $fullQualifiedClassName = ''; } else { $fullQualifiedClassName .= '\\'; } $fullQualifiedClassName .= $phpcsFile->getDeclarationName($currScope); } else { $declarationName = $phpcsFile->getDeclarationName($currScope); $fullQualifiedClassName = $tokens[$calledClassName]['content']; } if ($declarationName === $fullQualifiedClassName) { // Class name is the same as the current class, which is not allowed. $error = 'Must use "self::" for local static member reference'; $fix = $phpcsFile->addFixableError($error, $calledClassName, 'NotUsed'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $currentPointer = ($stackPtr - 1); while ($tokens[$currentPointer]['code'] === T_NS_SEPARATOR || $tokens[$currentPointer]['code'] === T_STRING || isset(Tokens::$emptyTokens[$tokens[$currentPointer]['code']]) === true ) { if (isset(Tokens::$emptyTokens[$tokens[$currentPointer]['code']]) === true) { --$currentPointer; continue; } $phpcsFile->fixer->replaceToken($currentPointer, ''); --$currentPointer; } $phpcsFile->fixer->replaceToken($stackPtr, 'self::'); $phpcsFile->fixer->endChangeset(); // Fix potential whitespace issues in the next loop. return; }//end if }//end if }//end if if ($tokens[($stackPtr - 1)]['code'] === T_WHITESPACE) { $found = $tokens[($stackPtr - 1)]['length']; $error = 'Expected 0 spaces before double colon; %s found'; $data = [$found]; $fix = $phpcsFile->addFixableError($error, ($stackPtr - 1), 'SpaceBefore', $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($stackPtr - 1); $tokens[$i]['code'] === T_WHITESPACE; $i--) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } } if ($tokens[($stackPtr + 1)]['code'] === T_WHITESPACE) { $found = $tokens[($stackPtr + 1)]['length']; $error = 'Expected 0 spaces after double colon; %s found'; $data = [$found]; $fix = $phpcsFile->addFixableError($error, ($stackPtr - 1), 'SpaceAfter', $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($stackPtr + 1); $tokens[$i]['code'] === T_WHITESPACE; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } } }//end processTokenWithinScope() /** * Processes a token that is found within the scope that this test is * listening to. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param int $stackPtr The position in the stack where this * token was found. * * @return void */ protected function processTokenOutsideScope(File $phpcsFile, $stackPtr) { }//end processTokenOutsideScope() /** * Returns the declaration names for classes/interfaces/functions with a namespace. * * @param array $tokens Token stack for this file * @param int $stackPtr The position where the namespace building will start. * * @return string */ protected function getDeclarationNameWithNamespace(array $tokens, $stackPtr) { $nameParts = []; $currentPointer = $stackPtr; while ($tokens[$currentPointer]['code'] === T_NS_SEPARATOR || $tokens[$currentPointer]['code'] === T_STRING || isset(Tokens::$emptyTokens[$tokens[$currentPointer]['code']]) === true ) { if (isset(Tokens::$emptyTokens[$tokens[$currentPointer]['code']]) === true) { --$currentPointer; continue; } $nameParts[] = $tokens[$currentPointer]['content']; --$currentPointer; } $nameParts = array_reverse($nameParts); return implode('', $nameParts); }//end getDeclarationNameWithNamespace() /** * Returns the namespace declaration of a file. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param int $stackPtr The position where the search for the * namespace declaration will start. * * @return string */ protected function getNamespaceOfScope(File $phpcsFile, $stackPtr) { $namespace = '\\'; $namespaceDeclaration = $phpcsFile->findPrevious(T_NAMESPACE, $stackPtr); if ($namespaceDeclaration !== false) { $endOfNamespaceDeclaration = $phpcsFile->findNext([T_SEMICOLON, T_OPEN_CURLY_BRACKET], $namespaceDeclaration); $namespace = $this->getDeclarationNameWithNamespace( $phpcsFile->getTokens(), ($endOfNamespaceDeclaration - 1) ); } return $namespace; }//end getNamespaceOfScope() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Classes/ValidClassNameSniff.php0000644000076500000240000000543713614652362027325 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Classes; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Common; class ValidClassNameSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_CLASS, T_INTERFACE, T_TRAIT, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being processed. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['scope_opener']) === false) { $error = 'Possible parse error: %s missing opening or closing brace'; $data = [$tokens[$stackPtr]['content']]; $phpcsFile->addWarning($error, $stackPtr, 'MissingBrace', $data); return; } // Determine the name of the class or interface. Note that we cannot // simply look for the first T_STRING because a class name // starting with the number will be multiple tokens. $opener = $tokens[$stackPtr]['scope_opener']; $nameStart = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), $opener, true); $nameEnd = $phpcsFile->findNext(T_WHITESPACE, $nameStart, $opener); if ($nameEnd === false) { $name = $tokens[$nameStart]['content']; } else { $name = trim($phpcsFile->getTokensAsString($nameStart, ($nameEnd - $nameStart))); } // Check for PascalCase format. $valid = Common::isCamelCaps($name, true, true, false); if ($valid === false) { $type = ucfirst($tokens[$stackPtr]['content']); $error = '%s name "%s" is not in PascalCase format'; $data = [ $type, $name, ]; $phpcsFile->addError($error, $stackPtr, 'NotCamelCaps', $data); $phpcsFile->recordMetric($stackPtr, 'PascalCase class name', 'no'); } else { $phpcsFile->recordMetric($stackPtr, 'PascalCase class name', 'yes'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Commenting/BlockCommentSniff.php0000644000076500000240000003553113614652362027555 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Commenting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class BlockCommentSniff implements Sniff { /** * The --tab-width CLI value that is being used. * * @var integer */ private $tabWidth = null; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_COMMENT, T_DOC_COMMENT_OPEN_TAG, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { if ($this->tabWidth === null) { if (isset($phpcsFile->config->tabWidth) === false || $phpcsFile->config->tabWidth === 0) { // We have no idea how wide tabs are, so assume 4 spaces for fixing. $this->tabWidth = 4; } else { $this->tabWidth = $phpcsFile->config->tabWidth; } } $tokens = $phpcsFile->getTokens(); // If it's an inline comment, return. if (substr($tokens[$stackPtr]['content'], 0, 2) !== '/*') { return; } // If this is a function/class/interface doc block comment, skip it. // We are only interested in inline doc block comments. if ($tokens[$stackPtr]['code'] === T_DOC_COMMENT_OPEN_TAG) { $nextToken = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true); $ignore = [ T_CLASS => true, T_INTERFACE => true, T_TRAIT => true, T_FUNCTION => true, T_PUBLIC => true, T_PRIVATE => true, T_FINAL => true, T_PROTECTED => true, T_STATIC => true, T_ABSTRACT => true, T_CONST => true, T_VAR => true, ]; if (isset($ignore[$tokens[$nextToken]['code']]) === true) { return; } $prevToken = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); if ($tokens[$prevToken]['code'] === T_OPEN_TAG) { return; } $error = 'Block comments must be started with /*'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'WrongStart'); if ($fix === true) { $phpcsFile->fixer->replaceToken($stackPtr, '/*'); } $end = $tokens[$stackPtr]['comment_closer']; if ($tokens[$end]['content'] !== '*/') { $error = 'Block comments must be ended with */'; $fix = $phpcsFile->addFixableError($error, $end, 'WrongEnd'); if ($fix === true) { $phpcsFile->fixer->replaceToken($end, '*/'); } } return; }//end if $commentLines = [$stackPtr]; $nextComment = $stackPtr; $lastLine = $tokens[$stackPtr]['line']; $commentString = $tokens[$stackPtr]['content']; // Construct the comment into an array. while (($nextComment = $phpcsFile->findNext(T_WHITESPACE, ($nextComment + 1), null, true)) !== false) { if ($tokens[$nextComment]['code'] !== $tokens[$stackPtr]['code'] && isset(Tokens::$phpcsCommentTokens[$tokens[$nextComment]['code']]) === false ) { // Found the next bit of code. break; } if (($tokens[$nextComment]['line'] - 1) !== $lastLine) { // Not part of the block. break; } $lastLine = $tokens[$nextComment]['line']; $commentLines[] = $nextComment; $commentString .= $tokens[$nextComment]['content']; if ($tokens[$nextComment]['code'] === T_DOC_COMMENT_CLOSE_TAG || substr($tokens[$nextComment]['content'], -2) === '*/' ) { break; } }//end while $commentText = str_replace($phpcsFile->eolChar, '', $commentString); $commentText = trim($commentText, "/* \t"); if ($commentText === '') { $error = 'Empty block comment not allowed'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Empty'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->replaceToken($stackPtr, ''); $lastToken = array_pop($commentLines); for ($i = ($stackPtr + 1); $i <= $lastToken; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } return; } if (count($commentLines) === 1) { $error = 'Single line block comment not allowed; use inline ("// text") comment instead'; // Only fix comments when they are the last token on a line. $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true); if ($tokens[$stackPtr]['line'] !== $tokens[$nextNonEmpty]['line']) { $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SingleLine'); if ($fix === true) { $comment = '// '.$commentText.$phpcsFile->eolChar; $phpcsFile->fixer->replaceToken($stackPtr, $comment); } } else { $phpcsFile->addError($error, $stackPtr, 'SingleLine'); } return; } $content = trim($tokens[$stackPtr]['content']); if ($content !== '/*' && $content !== '/**') { $error = 'Block comment text must start on a new line'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NoNewLine'); if ($fix === true) { $indent = ''; if ($tokens[($stackPtr - 1)]['code'] === T_WHITESPACE) { if (isset($tokens[($stackPtr - 1)]['orig_content']) === true) { $indent = $tokens[($stackPtr - 1)]['orig_content']; } else { $indent = $tokens[($stackPtr - 1)]['content']; } } $comment = preg_replace( '/^(\s*\/\*\*?)/', '$1'.$phpcsFile->eolChar.$indent, $tokens[$stackPtr]['content'], 1 ); $phpcsFile->fixer->replaceToken($stackPtr, $comment); } return; }//end if $starColumn = $tokens[$stackPtr]['column']; $hasStars = false; // Make sure first line isn't blank. if (trim($tokens[$commentLines[1]]['content']) === '') { $error = 'Empty line not allowed at start of comment'; $fix = $phpcsFile->addFixableError($error, $commentLines[1], 'HasEmptyLine'); if ($fix === true) { $phpcsFile->fixer->replaceToken($commentLines[1], ''); } } else { // Check indentation of first line. $content = $tokens[$commentLines[1]]['content']; $commentText = ltrim($content); $leadingSpace = (strlen($content) - strlen($commentText)); $expected = ($starColumn + 3); if ($commentText[0] === '*') { $expected = $starColumn; $hasStars = true; } if ($leadingSpace !== $expected) { $expectedTxt = $expected.' space'; if ($expected !== 1) { $expectedTxt .= 's'; } $data = [ $expectedTxt, $leadingSpace, ]; $error = 'First line of comment not aligned correctly; expected %s but found %s'; $fix = $phpcsFile->addFixableError($error, $commentLines[1], 'FirstLineIndent', $data); if ($fix === true) { if (isset($tokens[$commentLines[1]]['orig_content']) === true && $tokens[$commentLines[1]]['orig_content'][0] === "\t" ) { // Line is indented using tabs. $padding = str_repeat("\t", floor($expected / $this->tabWidth)); $padding .= str_repeat(' ', ($expected % $this->tabWidth)); } else { $padding = str_repeat(' ', $expected); } $phpcsFile->fixer->replaceToken($commentLines[1], $padding.$commentText); } }//end if if (preg_match('/^\p{Ll}/u', $commentText) === 1) { $error = 'Block comments must start with a capital letter'; $phpcsFile->addError($error, $commentLines[1], 'NoCapital'); } }//end if // Check that each line of the comment is indented past the star. foreach ($commentLines as $line) { // First and last lines (comment opener and closer) are handled separately. if ($line === $commentLines[(count($commentLines) - 1)] || $line === $commentLines[0]) { continue; } // First comment line was handled above. if ($line === $commentLines[1]) { continue; } // If it's empty, continue. if (trim($tokens[$line]['content']) === '') { continue; } $commentText = ltrim($tokens[$line]['content']); $leadingSpace = (strlen($tokens[$line]['content']) - strlen($commentText)); $expected = ($starColumn + 3); if ($commentText[0] === '*') { $expected = $starColumn; $hasStars = true; } if ($leadingSpace < $expected) { $expectedTxt = $expected.' space'; if ($expected !== 1) { $expectedTxt .= 's'; } $data = [ $expectedTxt, $leadingSpace, ]; $error = 'Comment line indented incorrectly; expected at least %s but found %s'; $fix = $phpcsFile->addFixableError($error, $line, 'LineIndent', $data); if ($fix === true) { if (isset($tokens[$line]['orig_content']) === true && $tokens[$line]['orig_content'][0] === "\t" ) { // Line is indented using tabs. $padding = str_repeat("\t", floor($expected / $this->tabWidth)); $padding .= str_repeat(' ', ($expected % $this->tabWidth)); } else { $padding = str_repeat(' ', $expected); } $phpcsFile->fixer->replaceToken($line, $padding.$commentText); } }//end if }//end foreach // Finally, test the last line is correct. $lastIndex = (count($commentLines) - 1); $content = $tokens[$commentLines[$lastIndex]]['content']; $commentText = ltrim($content); if ($commentText !== '*/' && $commentText !== '**/') { $error = 'Comment closer must be on a new line'; $phpcsFile->addError($error, $commentLines[$lastIndex], 'CloserSameLine'); } else { $leadingSpace = (strlen($content) - strlen($commentText)); $expected = ($starColumn - 1); if ($hasStars === true) { $expected = $starColumn; } if ($leadingSpace !== $expected) { $expectedTxt = $expected.' space'; if ($expected !== 1) { $expectedTxt .= 's'; } $data = [ $expectedTxt, $leadingSpace, ]; $error = 'Last line of comment aligned incorrectly; expected %s but found %s'; $fix = $phpcsFile->addFixableError($error, $commentLines[$lastIndex], 'LastLineIndent', $data); if ($fix === true) { if (isset($tokens[$line]['orig_content']) === true && $tokens[$line]['orig_content'][0] === "\t" ) { // Line is indented using tabs. $padding = str_repeat("\t", floor($expected / $this->tabWidth)); $padding .= str_repeat(' ', ($expected % $this->tabWidth)); } else { $padding = str_repeat(' ', $expected); } $phpcsFile->fixer->replaceToken($commentLines[$lastIndex], $padding.$commentText); } }//end if }//end if // Check that the lines before and after this comment are blank. $contentBefore = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true); if ((isset($tokens[$contentBefore]['scope_closer']) === true && $tokens[$contentBefore]['scope_opener'] === $contentBefore) || $tokens[$contentBefore]['code'] === T_OPEN_TAG ) { if (($tokens[$stackPtr]['line'] - $tokens[$contentBefore]['line']) !== 1) { $error = 'Empty line not required before block comment'; $phpcsFile->addError($error, $stackPtr, 'HasEmptyLineBefore'); } } else { if (($tokens[$stackPtr]['line'] - $tokens[$contentBefore]['line']) < 2) { $error = 'Empty line required before block comment'; $phpcsFile->addError($error, $stackPtr, 'NoEmptyLineBefore'); } } $commentCloser = $commentLines[$lastIndex]; $contentAfter = $phpcsFile->findNext(T_WHITESPACE, ($commentCloser + 1), null, true); if ($contentAfter !== false && ($tokens[$contentAfter]['line'] - $tokens[$commentCloser]['line']) < 2) { $error = 'Empty line required after block comment'; $phpcsFile->addError($error, $commentCloser, 'NoEmptyLineAfter'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Commenting/ClassCommentSniff.php0000644000076500000240000000544613614652362027572 0ustar gsherwoodstaff *
  • A class doc comment exists.
    • *
  • The comment uses the correct docblock style.
    • *
  • There are no blank lines after the class comment.
    • *
  • No tags are used in the docblock.
    • * * * @author Greg Sherwood * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Commenting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class ClassCommentSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_CLASS]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $find = Tokens::$methodPrefixes; $find[] = T_WHITESPACE; $commentEnd = $phpcsFile->findPrevious($find, ($stackPtr - 1), null, true); if ($tokens[$commentEnd]['code'] !== T_DOC_COMMENT_CLOSE_TAG && $tokens[$commentEnd]['code'] !== T_COMMENT ) { $class = $phpcsFile->getDeclarationName($stackPtr); $phpcsFile->addError('Missing doc comment for class %s', $stackPtr, 'Missing', [$class]); $phpcsFile->recordMetric($stackPtr, 'Class has doc comment', 'no'); return; } $phpcsFile->recordMetric($stackPtr, 'Class has doc comment', 'yes'); if ($tokens[$commentEnd]['code'] === T_COMMENT) { $phpcsFile->addError('You must use "/**" style comments for a class comment', $stackPtr, 'WrongStyle'); return; } if ($tokens[$commentEnd]['line'] !== ($tokens[$stackPtr]['line'] - 1)) { $error = 'There must be no blank lines after the class comment'; $phpcsFile->addError($error, $commentEnd, 'SpacingAfter'); } $commentStart = $tokens[$commentEnd]['comment_opener']; foreach ($tokens[$commentStart]['comment_tags'] as $tag) { $error = '%s tag is not allowed in class comment'; $data = [$tokens[$tag]['content']]; $phpcsFile->addWarning($error, $tag, 'TagNotAllowed', $data); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Commenting/ClosingDeclarationCommentSniff.php0000644000076500000240000001104113614652362032255 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Commenting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class ClosingDeclarationCommentSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_FUNCTION, T_CLASS, T_INTERFACE, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens.. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if ($tokens[$stackPtr]['code'] === T_FUNCTION) { $methodProps = $phpcsFile->getMethodProperties($stackPtr); // Abstract methods do not require a closing comment. if ($methodProps['is_abstract'] === true) { return; } // If this function is in an interface then we don't require // a closing comment. if ($phpcsFile->hasCondition($stackPtr, T_INTERFACE) === true) { return; } if (isset($tokens[$stackPtr]['scope_closer']) === false) { $error = 'Possible parse error: non-abstract method defined as abstract'; $phpcsFile->addWarning($error, $stackPtr, 'Abstract'); return; } $decName = $phpcsFile->getDeclarationName($stackPtr); $comment = '//end '.$decName.'()'; } else if ($tokens[$stackPtr]['code'] === T_CLASS) { $comment = '//end class'; } else { $comment = '//end interface'; }//end if if (isset($tokens[$stackPtr]['scope_closer']) === false) { $error = 'Possible parse error: %s missing opening or closing brace'; $data = [$tokens[$stackPtr]['content']]; $phpcsFile->addWarning($error, $stackPtr, 'MissingBrace', $data); return; } $closingBracket = $tokens[$stackPtr]['scope_closer']; if ($closingBracket === null) { // Possible inline structure. Other tests will handle it. return; } $data = [$comment]; if (isset($tokens[($closingBracket + 1)]) === false || $tokens[($closingBracket + 1)]['code'] !== T_COMMENT) { $next = $phpcsFile->findNext(T_WHITESPACE, ($closingBracket + 1), null, true); if (rtrim($tokens[$next]['content']) === $comment) { // The comment isn't really missing; it is just in the wrong place. $fix = $phpcsFile->addFixableError('Expected %s directly after closing brace', $closingBracket, 'Misplaced', $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($closingBracket + 1); $i < $next; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } // Just in case, because indentation fixes can add indents onto // these comments and cause us to be unable to fix them. $phpcsFile->fixer->replaceToken($next, $comment.$phpcsFile->eolChar); $phpcsFile->fixer->endChangeset(); } } else { $fix = $phpcsFile->addFixableError('Expected %s', $closingBracket, 'Missing', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken($closingBracket, '}'.$comment.$phpcsFile->eolChar); } } return; }//end if if (rtrim($tokens[($closingBracket + 1)]['content']) !== $comment) { $fix = $phpcsFile->addFixableError('Expected %s', $closingBracket, 'Incorrect', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($closingBracket + 1), $comment.$phpcsFile->eolChar); } return; } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Commenting/DocCommentAlignmentSniff.php0000644000076500000240000001260213614652362031061 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Commenting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class DocCommentAlignmentSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_DOC_COMMENT_OPEN_TAG]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // We are only interested in function/class/interface doc block comments. $ignore = Tokens::$emptyTokens; if ($phpcsFile->tokenizerType === 'JS') { $ignore[] = T_EQUAL; $ignore[] = T_STRING; $ignore[] = T_OBJECT_OPERATOR; } $nextToken = $phpcsFile->findNext($ignore, ($stackPtr + 1), null, true); $ignore = [ T_CLASS => true, T_INTERFACE => true, T_FUNCTION => true, T_PUBLIC => true, T_PRIVATE => true, T_PROTECTED => true, T_STATIC => true, T_ABSTRACT => true, T_PROPERTY => true, T_OBJECT => true, T_PROTOTYPE => true, T_VAR => true, ]; if ($nextToken === false || isset($ignore[$tokens[$nextToken]['code']]) === false) { // Could be a file comment. $prevToken = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); if ($tokens[$prevToken]['code'] !== T_OPEN_TAG) { return; } } // There must be one space after each star (unless it is an empty comment line) // and all the stars must be aligned correctly. $requiredColumn = ($tokens[$stackPtr]['column'] + 1); $endComment = $tokens[$stackPtr]['comment_closer']; for ($i = ($stackPtr + 1); $i <= $endComment; $i++) { if ($tokens[$i]['code'] !== T_DOC_COMMENT_STAR && $tokens[$i]['code'] !== T_DOC_COMMENT_CLOSE_TAG ) { continue; } if ($tokens[$i]['code'] === T_DOC_COMMENT_CLOSE_TAG) { if (trim($tokens[$i]['content']) === '') { // Don't process an unfinished docblock close tag during live coding. continue; } // Can't process the close tag if it is not the first thing on the line. $prev = $phpcsFile->findPrevious(T_DOC_COMMENT_WHITESPACE, ($i - 1), $stackPtr, true); if ($tokens[$prev]['line'] === $tokens[$i]['line']) { continue; } } if ($tokens[$i]['column'] !== $requiredColumn) { $error = 'Expected %s space(s) before asterisk; %s found'; $data = [ ($requiredColumn - 1), ($tokens[$i]['column'] - 1), ]; $fix = $phpcsFile->addFixableError($error, $i, 'SpaceBeforeStar', $data); if ($fix === true) { $padding = str_repeat(' ', ($requiredColumn - 1)); if ($tokens[$i]['column'] === 1) { $phpcsFile->fixer->addContentBefore($i, $padding); } else { $phpcsFile->fixer->replaceToken(($i - 1), $padding); } } } if ($tokens[$i]['code'] !== T_DOC_COMMENT_STAR) { continue; } if ($tokens[($i + 2)]['line'] !== $tokens[$i]['line']) { // Line is empty. continue; } if ($tokens[($i + 1)]['code'] !== T_DOC_COMMENT_WHITESPACE) { $error = 'Expected 1 space after asterisk; 0 found'; $fix = $phpcsFile->addFixableError($error, $i, 'NoSpaceAfterStar'); if ($fix === true) { $phpcsFile->fixer->addContent($i, ' '); } } else if ($tokens[($i + 2)]['code'] === T_DOC_COMMENT_TAG && $tokens[($i + 1)]['content'] !== ' ' ) { $error = 'Expected 1 space after asterisk; %s found'; $data = [$tokens[($i + 1)]['length']]; $fix = $phpcsFile->addFixableError($error, $i, 'SpaceAfterStar', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($i + 1), ' '); } } }//end for }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Commenting/EmptyCatchCommentSniff.php0000644000076500000240000000305413614652362030557 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Commenting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class EmptyCatchCommentSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_CATCH]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile All the tokens found in the document. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $scopeStart = $tokens[$stackPtr]['scope_opener']; $firstContent = $phpcsFile->findNext(T_WHITESPACE, ($scopeStart + 1), $tokens[$stackPtr]['scope_closer'], true); if ($firstContent === false) { $error = 'Empty CATCH statement must have a comment to explain why the exception is not handled'; $phpcsFile->addError($error, $scopeStart, 'Missing'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Commenting/FileCommentSniff.php0000644000076500000240000001737013614652362027403 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Commenting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class FileCommentSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return int */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $commentStart = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($tokens[$commentStart]['code'] === T_COMMENT) { $phpcsFile->addError('You must use "/**" style comments for a file comment', $commentStart, 'WrongStyle'); $phpcsFile->recordMetric($stackPtr, 'File has doc comment', 'yes'); return ($phpcsFile->numTokens + 1); } else if ($commentStart === false || $tokens[$commentStart]['code'] !== T_DOC_COMMENT_OPEN_TAG) { $phpcsFile->addError('Missing file doc comment', $stackPtr, 'Missing'); $phpcsFile->recordMetric($stackPtr, 'File has doc comment', 'no'); return ($phpcsFile->numTokens + 1); } if (isset($tokens[$commentStart]['comment_closer']) === false || ($tokens[$tokens[$commentStart]['comment_closer']]['content'] === '' && $tokens[$commentStart]['comment_closer'] === ($phpcsFile->numTokens - 1)) ) { // Don't process an unfinished file comment during live coding. return ($phpcsFile->numTokens + 1); } $commentEnd = $tokens[$commentStart]['comment_closer']; $nextToken = $phpcsFile->findNext( T_WHITESPACE, ($commentEnd + 1), null, true ); $ignore = [ T_CLASS, T_INTERFACE, T_TRAIT, T_FUNCTION, T_CLOSURE, T_PUBLIC, T_PRIVATE, T_PROTECTED, T_FINAL, T_STATIC, T_ABSTRACT, T_CONST, T_PROPERTY, T_INCLUDE, T_INCLUDE_ONCE, T_REQUIRE, T_REQUIRE_ONCE, ]; if (in_array($tokens[$nextToken]['code'], $ignore, true) === true) { $phpcsFile->addError('Missing file doc comment', $stackPtr, 'Missing'); $phpcsFile->recordMetric($stackPtr, 'File has doc comment', 'no'); return ($phpcsFile->numTokens + 1); } $phpcsFile->recordMetric($stackPtr, 'File has doc comment', 'yes'); // No blank line between the open tag and the file comment. if ($tokens[$commentStart]['line'] > ($tokens[$stackPtr]['line'] + 1)) { $error = 'There must be no blank lines before the file comment'; $phpcsFile->addError($error, $stackPtr, 'SpacingAfterOpen'); } // Exactly one blank line after the file comment. $next = $phpcsFile->findNext(T_WHITESPACE, ($commentEnd + 1), null, true); if ($tokens[$next]['line'] !== ($tokens[$commentEnd]['line'] + 2)) { $error = 'There must be exactly one blank line after the file comment'; $phpcsFile->addError($error, $commentEnd, 'SpacingAfterComment'); } // Required tags in correct order. $required = [ '@package' => true, '@subpackage' => true, '@author' => true, '@copyright' => true, ]; $foundTags = []; foreach ($tokens[$commentStart]['comment_tags'] as $tag) { $name = $tokens[$tag]['content']; $isRequired = isset($required[$name]); if ($isRequired === true && in_array($name, $foundTags, true) === true) { $error = 'Only one %s tag is allowed in a file comment'; $data = [$name]; $phpcsFile->addError($error, $tag, 'Duplicate'.ucfirst(substr($name, 1)).'Tag', $data); } $foundTags[] = $name; if ($isRequired === false) { continue; } $string = $phpcsFile->findNext(T_DOC_COMMENT_STRING, $tag, $commentEnd); if ($string === false || $tokens[$string]['line'] !== $tokens[$tag]['line']) { $error = 'Content missing for %s tag in file comment'; $data = [$name]; $phpcsFile->addError($error, $tag, 'Empty'.ucfirst(substr($name, 1)).'Tag', $data); continue; } if ($name === '@author') { if ($tokens[$string]['content'] !== 'Squiz Pty Ltd ') { $error = 'Expected "Squiz Pty Ltd " for author tag'; $fix = $phpcsFile->addFixableError($error, $tag, 'IncorrectAuthor'); if ($fix === true) { $expected = 'Squiz Pty Ltd '; $phpcsFile->fixer->replaceToken($string, $expected); } } } else if ($name === '@copyright') { if (preg_match('/^([0-9]{4})(-[0-9]{4})? (Squiz Pty Ltd \(ABN 77 084 670 600\))$/', $tokens[$string]['content']) === 0) { $error = 'Expected "xxxx-xxxx Squiz Pty Ltd (ABN 77 084 670 600)" for copyright declaration'; $fix = $phpcsFile->addFixableError($error, $tag, 'IncorrectCopyright'); if ($fix === true) { $matches = []; preg_match('/^(([0-9]{4})(-[0-9]{4})?)?.*$/', $tokens[$string]['content'], $matches); if (isset($matches[1]) === false) { $matches[1] = date('Y'); } $expected = $matches[1].' Squiz Pty Ltd (ABN 77 084 670 600)'; $phpcsFile->fixer->replaceToken($string, $expected); } } }//end if }//end foreach // Check if the tags are in the correct position. $pos = 0; foreach ($required as $tag => $true) { if (in_array($tag, $foundTags, true) === false) { $error = 'Missing %s tag in file comment'; $data = [$tag]; $phpcsFile->addError($error, $commentEnd, 'Missing'.ucfirst(substr($tag, 1)).'Tag', $data); } if (isset($foundTags[$pos]) === false) { break; } if ($foundTags[$pos] !== $tag) { $error = 'The tag in position %s should be the %s tag'; $data = [ ($pos + 1), $tag, ]; $phpcsFile->addError($error, $tokens[$commentStart]['comment_tags'][$pos], ucfirst(substr($tag, 1)).'TagOrder', $data); } $pos++; }//end foreach // Ignore the rest of the file. return ($phpcsFile->numTokens + 1); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Commenting/FunctionCommentThrowTagSniff.php0000644000076500000240000002037613614652362031771 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Commenting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class FunctionCommentThrowTagSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_FUNCTION]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['scope_closer']) === false) { // Abstract or incomplete. return; } $find = Tokens::$methodPrefixes; $find[] = T_WHITESPACE; $commentEnd = $phpcsFile->findPrevious($find, ($stackPtr - 1), null, true); if ($tokens[$commentEnd]['code'] !== T_DOC_COMMENT_CLOSE_TAG) { // Function doesn't have a doc comment or is using the wrong type of comment. return; } $stackPtrEnd = $tokens[$stackPtr]['scope_closer']; // Find all the exception type tokens within the current scope. $thrownExceptions = []; $currPos = $stackPtr; $foundThrows = false; $unknownCount = 0; do { $currPos = $phpcsFile->findNext([T_THROW, T_ANON_CLASS, T_CLOSURE], ($currPos + 1), $stackPtrEnd); if ($currPos === false) { break; } if ($tokens[$currPos]['code'] !== T_THROW) { $currPos = $tokens[$currPos]['scope_closer']; continue; } $foundThrows = true; /* If we can't find a NEW, we are probably throwing a variable or calling a method. If we're throwing a variable, and it's the same variable as the exception container from the nearest 'catch' block, we take that exception as it is likely to be a re-throw. If we can't find a matching catch block, or the variable name is different, it's probably a different variable, so we ignore it, but they still need to provide at least one @throws tag, even through we don't know the exception class. */ $nextToken = $phpcsFile->findNext(T_WHITESPACE, ($currPos + 1), null, true); if ($tokens[$nextToken]['code'] === T_NEW || $tokens[$nextToken]['code'] === T_NS_SEPARATOR || $tokens[$nextToken]['code'] === T_STRING ) { if ($tokens[$nextToken]['code'] === T_NEW) { $currException = $phpcsFile->findNext( [ T_NS_SEPARATOR, T_STRING, ], $currPos, $stackPtrEnd, false, null, true ); } else { $currException = $nextToken; } if ($currException !== false) { $endException = $phpcsFile->findNext( [ T_NS_SEPARATOR, T_STRING, ], ($currException + 1), $stackPtrEnd, true, null, true ); if ($endException === false) { $thrownExceptions[] = $tokens[$currException]['content']; } else { $thrownExceptions[] = $phpcsFile->getTokensAsString($currException, ($endException - $currException)); } }//end if } else if ($tokens[$nextToken]['code'] === T_VARIABLE) { // Find the nearest catch block in this scope and, if the caught var // matches our re-thrown var, use the exception types being caught as // exception types that are being thrown as well. $catch = $phpcsFile->findPrevious( T_CATCH, $currPos, $tokens[$stackPtr]['scope_opener'], false, null, false ); if ($catch !== false) { $thrownVar = $phpcsFile->findPrevious( T_VARIABLE, ($tokens[$catch]['parenthesis_closer'] - 1), $tokens[$catch]['parenthesis_opener'] ); if ($tokens[$thrownVar]['content'] === $tokens[$nextToken]['content']) { $exceptions = explode('|', $phpcsFile->getTokensAsString(($tokens[$catch]['parenthesis_opener'] + 1), ($thrownVar - $tokens[$catch]['parenthesis_opener'] - 1))); foreach ($exceptions as $exception) { $thrownExceptions[] = trim($exception); } } } } else { ++$unknownCount; }//end if } while ($currPos < $stackPtrEnd && $currPos !== false); if ($foundThrows === false) { return; } // Only need one @throws tag for each type of exception thrown. $thrownExceptions = array_unique($thrownExceptions); $throwTags = []; $commentStart = $tokens[$commentEnd]['comment_opener']; foreach ($tokens[$commentStart]['comment_tags'] as $tag) { if ($tokens[$tag]['content'] !== '@throws') { continue; } if ($tokens[($tag + 2)]['code'] === T_DOC_COMMENT_STRING) { $exception = $tokens[($tag + 2)]['content']; $space = strpos($exception, ' '); if ($space !== false) { $exception = substr($exception, 0, $space); } $throwTags[$exception] = true; } } if (empty($throwTags) === true) { $error = 'Missing @throws tag in function comment'; $phpcsFile->addError($error, $commentEnd, 'Missing'); return; } else if (empty($thrownExceptions) === true) { // If token count is zero, it means that only variables are being // thrown, so we need at least one @throws tag (checked above). // Nothing more to do. return; } // Make sure @throws tag count matches thrown count. $thrownCount = (count($thrownExceptions) + $unknownCount); $tagCount = count($throwTags); if ($thrownCount !== $tagCount) { $error = 'Expected %s @throws tag(s) in function comment; %s found'; $data = [ $thrownCount, $tagCount, ]; $phpcsFile->addError($error, $commentEnd, 'WrongNumber', $data); return; } foreach ($thrownExceptions as $throw) { if (isset($throwTags[$throw]) === true) { continue; } foreach ($throwTags as $tag => $ignore) { if (strrpos($tag, $throw) === (strlen($tag) - strlen($throw))) { continue 2; } } $error = 'Missing @throws tag for "%s" exception'; $data = [$throw]; $phpcsFile->addError($error, $commentEnd, 'Missing', $data); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Commenting/FunctionCommentSniff.php0000644000076500000240000007261513614652362030314 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Commenting; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Standards\PEAR\Sniffs\Commenting\FunctionCommentSniff as PEARFunctionCommentSniff; use PHP_CodeSniffer\Util\Common; class FunctionCommentSniff extends PEARFunctionCommentSniff { /** * The current PHP version. * * @var integer */ private $phpVersion = null; /** * Process the return comment of this function comment. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param int $commentStart The position in the stack where the comment started. * * @return void */ protected function processReturn(File $phpcsFile, $stackPtr, $commentStart) { $tokens = $phpcsFile->getTokens(); $return = null; foreach ($tokens[$commentStart]['comment_tags'] as $tag) { if ($tokens[$tag]['content'] === '@return') { if ($return !== null) { $error = 'Only 1 @return tag is allowed in a function comment'; $phpcsFile->addError($error, $tag, 'DuplicateReturn'); return; } $return = $tag; } } // Skip constructor and destructor. $methodName = $phpcsFile->getDeclarationName($stackPtr); $isSpecialMethod = ($methodName === '__construct' || $methodName === '__destruct'); if ($isSpecialMethod === true) { return; } if ($return !== null) { $content = $tokens[($return + 2)]['content']; if (empty($content) === true || $tokens[($return + 2)]['code'] !== T_DOC_COMMENT_STRING) { $error = 'Return type missing for @return tag in function comment'; $phpcsFile->addError($error, $return, 'MissingReturnType'); } else { // Support both a return type and a description. preg_match('`^((?:\|?(?:array\([^\)]*\)|[\\\\a-z0-9\[\]]+))*)( .*)?`i', $content, $returnParts); if (isset($returnParts[1]) === false) { return; } $returnType = $returnParts[1]; // Check return type (can be multiple, separated by '|'). $typeNames = explode('|', $returnType); $suggestedNames = []; foreach ($typeNames as $i => $typeName) { $suggestedName = Common::suggestType($typeName); if (in_array($suggestedName, $suggestedNames, true) === false) { $suggestedNames[] = $suggestedName; } } $suggestedType = implode('|', $suggestedNames); if ($returnType !== $suggestedType) { $error = 'Expected "%s" but found "%s" for function return type'; $data = [ $suggestedType, $returnType, ]; $fix = $phpcsFile->addFixableError($error, $return, 'InvalidReturn', $data); if ($fix === true) { $replacement = $suggestedType; if (empty($returnParts[2]) === false) { $replacement .= $returnParts[2]; } $phpcsFile->fixer->replaceToken(($return + 2), $replacement); unset($replacement); } } // If the return type is void, make sure there is // no return statement in the function. if ($returnType === 'void') { if (isset($tokens[$stackPtr]['scope_closer']) === true) { $endToken = $tokens[$stackPtr]['scope_closer']; for ($returnToken = $stackPtr; $returnToken < $endToken; $returnToken++) { if ($tokens[$returnToken]['code'] === T_CLOSURE || $tokens[$returnToken]['code'] === T_ANON_CLASS ) { $returnToken = $tokens[$returnToken]['scope_closer']; continue; } if ($tokens[$returnToken]['code'] === T_RETURN || $tokens[$returnToken]['code'] === T_YIELD || $tokens[$returnToken]['code'] === T_YIELD_FROM ) { break; } } if ($returnToken !== $endToken) { // If the function is not returning anything, just // exiting, then there is no problem. $semicolon = $phpcsFile->findNext(T_WHITESPACE, ($returnToken + 1), null, true); if ($tokens[$semicolon]['code'] !== T_SEMICOLON) { $error = 'Function return type is void, but function contains return statement'; $phpcsFile->addError($error, $return, 'InvalidReturnVoid'); } } }//end if } else if ($returnType !== 'mixed' && in_array('void', $typeNames, true) === false) { // If return type is not void, there needs to be a return statement // somewhere in the function that returns something. if (isset($tokens[$stackPtr]['scope_closer']) === true) { $endToken = $tokens[$stackPtr]['scope_closer']; for ($returnToken = $stackPtr; $returnToken < $endToken; $returnToken++) { if ($tokens[$returnToken]['code'] === T_CLOSURE || $tokens[$returnToken]['code'] === T_ANON_CLASS ) { $returnToken = $tokens[$returnToken]['scope_closer']; continue; } if ($tokens[$returnToken]['code'] === T_RETURN || $tokens[$returnToken]['code'] === T_YIELD || $tokens[$returnToken]['code'] === T_YIELD_FROM ) { break; } } if ($returnToken === $endToken) { $error = 'Function return type is not void, but function has no return statement'; $phpcsFile->addError($error, $return, 'InvalidNoReturn'); } else { $semicolon = $phpcsFile->findNext(T_WHITESPACE, ($returnToken + 1), null, true); if ($tokens[$semicolon]['code'] === T_SEMICOLON) { $error = 'Function return type is not void, but function is returning void here'; $phpcsFile->addError($error, $returnToken, 'InvalidReturnNotVoid'); } } }//end if }//end if }//end if } else { $error = 'Missing @return tag in function comment'; $phpcsFile->addError($error, $tokens[$commentStart]['comment_closer'], 'MissingReturn'); }//end if }//end processReturn() /** * Process any throw tags that this function comment has. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param int $commentStart The position in the stack where the comment started. * * @return void */ protected function processThrows(File $phpcsFile, $stackPtr, $commentStart) { $tokens = $phpcsFile->getTokens(); foreach ($tokens[$commentStart]['comment_tags'] as $pos => $tag) { if ($tokens[$tag]['content'] !== '@throws') { continue; } $exception = null; $comment = null; if ($tokens[($tag + 2)]['code'] === T_DOC_COMMENT_STRING) { $matches = []; preg_match('/([^\s]+)(?:\s+(.*))?/', $tokens[($tag + 2)]['content'], $matches); $exception = $matches[1]; if (isset($matches[2]) === true && trim($matches[2]) !== '') { $comment = $matches[2]; } } if ($exception === null) { $error = 'Exception type and comment missing for @throws tag in function comment'; $phpcsFile->addError($error, $tag, 'InvalidThrows'); } else if ($comment === null) { $error = 'Comment missing for @throws tag in function comment'; $phpcsFile->addError($error, $tag, 'EmptyThrows'); } else { // Any strings until the next tag belong to this comment. if (isset($tokens[$commentStart]['comment_tags'][($pos + 1)]) === true) { $end = $tokens[$commentStart]['comment_tags'][($pos + 1)]; } else { $end = $tokens[$commentStart]['comment_closer']; } for ($i = ($tag + 3); $i < $end; $i++) { if ($tokens[$i]['code'] === T_DOC_COMMENT_STRING) { $comment .= ' '.$tokens[$i]['content']; } } // Starts with a capital letter and ends with a fullstop. $firstChar = $comment[0]; if (strtoupper($firstChar) !== $firstChar) { $error = '@throws tag comment must start with a capital letter'; $phpcsFile->addError($error, ($tag + 2), 'ThrowsNotCapital'); } $lastChar = substr($comment, -1); if ($lastChar !== '.') { $error = '@throws tag comment must end with a full stop'; $phpcsFile->addError($error, ($tag + 2), 'ThrowsNoFullStop'); } }//end if }//end foreach }//end processThrows() /** * Process the function parameter comments. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param int $commentStart The position in the stack where the comment started. * * @return void */ protected function processParams(File $phpcsFile, $stackPtr, $commentStart) { if ($this->phpVersion === null) { $this->phpVersion = Config::getConfigData('php_version'); if ($this->phpVersion === null) { $this->phpVersion = PHP_VERSION_ID; } } $tokens = $phpcsFile->getTokens(); $params = []; $maxType = 0; $maxVar = 0; foreach ($tokens[$commentStart]['comment_tags'] as $pos => $tag) { if ($tokens[$tag]['content'] !== '@param') { continue; } $type = ''; $typeSpace = 0; $var = ''; $varSpace = 0; $comment = ''; $commentLines = []; if ($tokens[($tag + 2)]['code'] === T_DOC_COMMENT_STRING) { $matches = []; preg_match('/([^$&.]+)(?:((?:\.\.\.)?(?:\$|&)[^\s]+)(?:(\s+)(.*))?)?/', $tokens[($tag + 2)]['content'], $matches); if (empty($matches) === false) { $typeLen = strlen($matches[1]); $type = trim($matches[1]); $typeSpace = ($typeLen - strlen($type)); $typeLen = strlen($type); if ($typeLen > $maxType) { $maxType = $typeLen; } } if (isset($matches[2]) === true) { $var = $matches[2]; $varLen = strlen($var); if ($varLen > $maxVar) { $maxVar = $varLen; } if (isset($matches[4]) === true) { $varSpace = strlen($matches[3]); $comment = $matches[4]; $commentLines[] = [ 'comment' => $comment, 'token' => ($tag + 2), 'indent' => $varSpace, ]; // Any strings until the next tag belong to this comment. if (isset($tokens[$commentStart]['comment_tags'][($pos + 1)]) === true) { $end = $tokens[$commentStart]['comment_tags'][($pos + 1)]; } else { $end = $tokens[$commentStart]['comment_closer']; } for ($i = ($tag + 3); $i < $end; $i++) { if ($tokens[$i]['code'] === T_DOC_COMMENT_STRING) { $indent = 0; if ($tokens[($i - 1)]['code'] === T_DOC_COMMENT_WHITESPACE) { $indent = $tokens[($i - 1)]['length']; } $comment .= ' '.$tokens[$i]['content']; $commentLines[] = [ 'comment' => $tokens[$i]['content'], 'token' => $i, 'indent' => $indent, ]; } } } else { $error = 'Missing parameter comment'; $phpcsFile->addError($error, $tag, 'MissingParamComment'); $commentLines[] = ['comment' => '']; }//end if } else { $error = 'Missing parameter name'; $phpcsFile->addError($error, $tag, 'MissingParamName'); }//end if } else { $error = 'Missing parameter type'; $phpcsFile->addError($error, $tag, 'MissingParamType'); }//end if $params[] = [ 'tag' => $tag, 'type' => $type, 'var' => $var, 'comment' => $comment, 'commentLines' => $commentLines, 'type_space' => $typeSpace, 'var_space' => $varSpace, ]; }//end foreach $realParams = $phpcsFile->getMethodParameters($stackPtr); $foundParams = []; // We want to use ... for all variable length arguments, so added // this prefix to the variable name so comparisons are easier. foreach ($realParams as $pos => $param) { if ($param['variable_length'] === true) { $realParams[$pos]['name'] = '...'.$realParams[$pos]['name']; } } foreach ($params as $pos => $param) { // If the type is empty, the whole line is empty. if ($param['type'] === '') { continue; } // Check the param type value. $typeNames = explode('|', $param['type']); $suggestedTypeNames = []; foreach ($typeNames as $typeName) { // Strip nullable operator. if ($typeName[0] === '?') { $typeName = substr($typeName, 1); } $suggestedName = Common::suggestType($typeName); $suggestedTypeNames[] = $suggestedName; if (count($typeNames) > 1) { continue; } // Check type hint for array and custom type. $suggestedTypeHint = ''; if (strpos($suggestedName, 'array') !== false || substr($suggestedName, -2) === '[]') { $suggestedTypeHint = 'array'; } else if (strpos($suggestedName, 'callable') !== false) { $suggestedTypeHint = 'callable'; } else if (strpos($suggestedName, 'callback') !== false) { $suggestedTypeHint = 'callable'; } else if (in_array($suggestedName, Common::$allowedTypes, true) === false) { $suggestedTypeHint = $suggestedName; } if ($this->phpVersion >= 70000) { if ($suggestedName === 'string') { $suggestedTypeHint = 'string'; } else if ($suggestedName === 'int' || $suggestedName === 'integer') { $suggestedTypeHint = 'int'; } else if ($suggestedName === 'float') { $suggestedTypeHint = 'float'; } else if ($suggestedName === 'bool' || $suggestedName === 'boolean') { $suggestedTypeHint = 'bool'; } } if ($this->phpVersion >= 70200) { if ($suggestedName === 'object') { $suggestedTypeHint = 'object'; } } if ($suggestedTypeHint !== '' && isset($realParams[$pos]) === true) { $typeHint = $realParams[$pos]['type_hint']; // Remove namespace prefixes when comparing. $compareTypeHint = substr($suggestedTypeHint, (strlen($typeHint) * -1)); if ($typeHint === '') { $error = 'Type hint "%s" missing for %s'; $data = [ $suggestedTypeHint, $param['var'], ]; $errorCode = 'TypeHintMissing'; if ($suggestedTypeHint === 'string' || $suggestedTypeHint === 'int' || $suggestedTypeHint === 'float' || $suggestedTypeHint === 'bool' ) { $errorCode = 'Scalar'.$errorCode; } $phpcsFile->addError($error, $stackPtr, $errorCode, $data); } else if ($typeHint !== $compareTypeHint && $typeHint !== '?'.$compareTypeHint) { $error = 'Expected type hint "%s"; found "%s" for %s'; $data = [ $suggestedTypeHint, $typeHint, $param['var'], ]; $phpcsFile->addError($error, $stackPtr, 'IncorrectTypeHint', $data); }//end if } else if ($suggestedTypeHint === '' && isset($realParams[$pos]) === true) { $typeHint = $realParams[$pos]['type_hint']; if ($typeHint !== '') { $error = 'Unknown type hint "%s" found for %s'; $data = [ $typeHint, $param['var'], ]; $phpcsFile->addError($error, $stackPtr, 'InvalidTypeHint', $data); } }//end if }//end foreach $suggestedType = implode('|', $suggestedTypeNames); if ($param['type'] !== $suggestedType) { $error = 'Expected "%s" but found "%s" for parameter type'; $data = [ $suggestedType, $param['type'], ]; $fix = $phpcsFile->addFixableError($error, $param['tag'], 'IncorrectParamVarName', $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $content = $suggestedType; $content .= str_repeat(' ', $param['type_space']); $content .= $param['var']; $content .= str_repeat(' ', $param['var_space']); if (isset($param['commentLines'][0]) === true) { $content .= $param['commentLines'][0]['comment']; } $phpcsFile->fixer->replaceToken(($param['tag'] + 2), $content); // Fix up the indent of additional comment lines. foreach ($param['commentLines'] as $lineNum => $line) { if ($lineNum === 0 || $param['commentLines'][$lineNum]['indent'] === 0 ) { continue; } $diff = (strlen($param['type']) - strlen($suggestedType)); $newIndent = ($param['commentLines'][$lineNum]['indent'] - $diff); $phpcsFile->fixer->replaceToken( ($param['commentLines'][$lineNum]['token'] - 1), str_repeat(' ', $newIndent) ); } $phpcsFile->fixer->endChangeset(); }//end if }//end if if ($param['var'] === '') { continue; } $foundParams[] = $param['var']; // Check number of spaces after the type. $this->checkSpacingAfterParamType($phpcsFile, $param, $maxType); // Make sure the param name is correct. if (isset($realParams[$pos]) === true) { $realName = $realParams[$pos]['name']; if ($realName !== $param['var']) { $code = 'ParamNameNoMatch'; $data = [ $param['var'], $realName, ]; $error = 'Doc comment for parameter %s does not match '; if (strtolower($param['var']) === strtolower($realName)) { $error .= 'case of '; $code = 'ParamNameNoCaseMatch'; } $error .= 'actual variable name %s'; $phpcsFile->addError($error, $param['tag'], $code, $data); } } else if (substr($param['var'], -4) !== ',...') { // We must have an extra parameter comment. $error = 'Superfluous parameter comment'; $phpcsFile->addError($error, $param['tag'], 'ExtraParamComment'); }//end if if ($param['comment'] === '') { continue; } // Check number of spaces after the var name. $this->checkSpacingAfterParamName($phpcsFile, $param, $maxVar); // Param comments must start with a capital letter and end with a full stop. if (preg_match('/^(\p{Ll}|\P{L})/u', $param['comment']) === 1) { $error = 'Parameter comment must start with a capital letter'; $phpcsFile->addError($error, $param['tag'], 'ParamCommentNotCapital'); } $lastChar = substr($param['comment'], -1); if ($lastChar !== '.') { $error = 'Parameter comment must end with a full stop'; $phpcsFile->addError($error, $param['tag'], 'ParamCommentFullStop'); } }//end foreach $realNames = []; foreach ($realParams as $realParam) { $realNames[] = $realParam['name']; } // Report missing comments. $diff = array_diff($realNames, $foundParams); foreach ($diff as $neededParam) { $error = 'Doc comment for parameter "%s" missing'; $data = [$neededParam]; $phpcsFile->addError($error, $commentStart, 'MissingParamTag', $data); } }//end processParams() /** * Check the spacing after the type of a parameter. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param array $param The parameter to be checked. * @param int $maxType The maxlength of the longest parameter type. * @param int $spacing The number of spaces to add after the type. * * @return void */ protected function checkSpacingAfterParamType(File $phpcsFile, $param, $maxType, $spacing=1) { // Check number of spaces after the type. $spaces = ($maxType - strlen($param['type']) + $spacing); if ($param['type_space'] !== $spaces) { $error = 'Expected %s spaces after parameter type; %s found'; $data = [ $spaces, $param['type_space'], ]; $fix = $phpcsFile->addFixableError($error, $param['tag'], 'SpacingAfterParamType', $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $content = $param['type']; $content .= str_repeat(' ', $spaces); $content .= $param['var']; $content .= str_repeat(' ', $param['var_space']); $content .= $param['commentLines'][0]['comment']; $phpcsFile->fixer->replaceToken(($param['tag'] + 2), $content); // Fix up the indent of additional comment lines. $diff = ($param['type_space'] - $spaces); foreach ($param['commentLines'] as $lineNum => $line) { if ($lineNum === 0 || $param['commentLines'][$lineNum]['indent'] === 0 ) { continue; } $newIndent = ($param['commentLines'][$lineNum]['indent'] - $diff); if ($newIndent <= 0) { continue; } $phpcsFile->fixer->replaceToken( ($param['commentLines'][$lineNum]['token'] - 1), str_repeat(' ', $newIndent) ); } $phpcsFile->fixer->endChangeset(); }//end if }//end if }//end checkSpacingAfterParamType() /** * Check the spacing after the name of a parameter. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param array $param The parameter to be checked. * @param int $maxVar The maxlength of the longest parameter name. * @param int $spacing The number of spaces to add after the type. * * @return void */ protected function checkSpacingAfterParamName(File $phpcsFile, $param, $maxVar, $spacing=1) { // Check number of spaces after the var name. $spaces = ($maxVar - strlen($param['var']) + $spacing); if ($param['var_space'] !== $spaces) { $error = 'Expected %s spaces after parameter name; %s found'; $data = [ $spaces, $param['var_space'], ]; $fix = $phpcsFile->addFixableError($error, $param['tag'], 'SpacingAfterParamName', $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $content = $param['type']; $content .= str_repeat(' ', $param['type_space']); $content .= $param['var']; $content .= str_repeat(' ', $spaces); $content .= $param['commentLines'][0]['comment']; $phpcsFile->fixer->replaceToken(($param['tag'] + 2), $content); // Fix up the indent of additional comment lines. foreach ($param['commentLines'] as $lineNum => $line) { if ($lineNum === 0 || $param['commentLines'][$lineNum]['indent'] === 0 ) { continue; } $diff = ($param['var_space'] - $spaces); $newIndent = ($param['commentLines'][$lineNum]['indent'] - $diff); if ($newIndent <= 0) { continue; } $phpcsFile->fixer->replaceToken( ($param['commentLines'][$lineNum]['token'] - 1), str_repeat(' ', $newIndent) ); } $phpcsFile->fixer->endChangeset(); }//end if }//end if }//end checkSpacingAfterParamName() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Commenting/InlineCommentSniff.php0000644000076500000240000003017013614652362027733 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Commenting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class InlineCommentSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_COMMENT, T_DOC_COMMENT_OPEN_TAG, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // If this is a function/class/interface doc block comment, skip it. // We are only interested in inline doc block comments, which are // not allowed. if ($tokens[$stackPtr]['code'] === T_DOC_COMMENT_OPEN_TAG) { $nextToken = $phpcsFile->findNext( Tokens::$emptyTokens, ($stackPtr + 1), null, true ); $ignore = [ T_CLASS, T_INTERFACE, T_TRAIT, T_FUNCTION, T_CLOSURE, T_PUBLIC, T_PRIVATE, T_PROTECTED, T_FINAL, T_STATIC, T_ABSTRACT, T_CONST, T_PROPERTY, T_INCLUDE, T_INCLUDE_ONCE, T_REQUIRE, T_REQUIRE_ONCE, ]; if (in_array($tokens[$nextToken]['code'], $ignore, true) === true) { return; } if ($phpcsFile->tokenizerType === 'JS') { // We allow block comments if a function or object // is being assigned to a variable. $ignore = Tokens::$emptyTokens; $ignore[] = T_EQUAL; $ignore[] = T_STRING; $ignore[] = T_OBJECT_OPERATOR; $nextToken = $phpcsFile->findNext($ignore, ($nextToken + 1), null, true); if ($tokens[$nextToken]['code'] === T_FUNCTION || $tokens[$nextToken]['code'] === T_CLOSURE || $tokens[$nextToken]['code'] === T_OBJECT || $tokens[$nextToken]['code'] === T_PROTOTYPE ) { return; } } $prevToken = $phpcsFile->findPrevious( Tokens::$emptyTokens, ($stackPtr - 1), null, true ); if ($tokens[$prevToken]['code'] === T_OPEN_TAG) { return; } if ($tokens[$stackPtr]['content'] === '/**') { $error = 'Inline doc block comments are not allowed; use "/* Comment */" or "// Comment" instead'; $phpcsFile->addError($error, $stackPtr, 'DocBlock'); } }//end if if ($tokens[$stackPtr]['content'][0] === '#') { $error = 'Perl-style comments are not allowed; use "// Comment" instead'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'WrongStyle'); if ($fix === true) { $comment = ltrim($tokens[$stackPtr]['content'], "# \t"); $phpcsFile->fixer->replaceToken($stackPtr, "// $comment"); } } // We don't want end of block comments. Check if the last token before the // comment is a closing curly brace. $previousContent = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true); if ($tokens[$previousContent]['line'] === $tokens[$stackPtr]['line']) { if ($tokens[$previousContent]['code'] === T_CLOSE_CURLY_BRACKET) { return; } // Special case for JS files. if ($tokens[$previousContent]['code'] === T_COMMA || $tokens[$previousContent]['code'] === T_SEMICOLON ) { $lastContent = $phpcsFile->findPrevious(T_WHITESPACE, ($previousContent - 1), null, true); if ($tokens[$lastContent]['code'] === T_CLOSE_CURLY_BRACKET) { return; } } } // Only want inline comments. if (substr($tokens[$stackPtr]['content'], 0, 2) !== '//') { return; } $commentTokens = [$stackPtr]; $nextComment = $stackPtr; $lastComment = $stackPtr; while (($nextComment = $phpcsFile->findNext(T_COMMENT, ($nextComment + 1), null, false)) !== false) { if ($tokens[$nextComment]['line'] !== ($tokens[$lastComment]['line'] + 1)) { break; } // Only want inline comments. if (substr($tokens[$nextComment]['content'], 0, 2) !== '//') { break; } // There is a comment on the very next line. If there is // no code between the comments, they are part of the same // comment block. $prevNonWhitespace = $phpcsFile->findPrevious(T_WHITESPACE, ($nextComment - 1), $lastComment, true); if ($prevNonWhitespace !== $lastComment) { break; } $commentTokens[] = $nextComment; $lastComment = $nextComment; }//end while $commentText = ''; foreach ($commentTokens as $lastCommentToken) { $comment = rtrim($tokens[$lastCommentToken]['content']); if (trim(substr($comment, 2)) === '') { continue; } $spaceCount = 0; $tabFound = false; $commentLength = strlen($comment); for ($i = 2; $i < $commentLength; $i++) { if ($comment[$i] === "\t") { $tabFound = true; break; } if ($comment[$i] !== ' ') { break; } $spaceCount++; } $fix = false; if ($tabFound === true) { $error = 'Tab found before comment text; expected "// %s" but found "%s"'; $data = [ ltrim(substr($comment, 2)), $comment, ]; $fix = $phpcsFile->addFixableError($error, $lastCommentToken, 'TabBefore', $data); } else if ($spaceCount === 0) { $error = 'No space found before comment text; expected "// %s" but found "%s"'; $data = [ substr($comment, 2), $comment, ]; $fix = $phpcsFile->addFixableError($error, $lastCommentToken, 'NoSpaceBefore', $data); } else if ($spaceCount > 1) { $error = 'Expected 1 space before comment text but found %s; use block comment if you need indentation'; $data = [ $spaceCount, substr($comment, (2 + $spaceCount)), $comment, ]; $fix = $phpcsFile->addFixableError($error, $lastCommentToken, 'SpacingBefore', $data); }//end if if ($fix === true) { $newComment = '// '.ltrim($tokens[$lastCommentToken]['content'], "/\t "); $phpcsFile->fixer->replaceToken($lastCommentToken, $newComment); } $commentText .= trim(substr($tokens[$lastCommentToken]['content'], 2)); }//end foreach if ($commentText === '') { $error = 'Blank comments are not allowed'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Empty'); if ($fix === true) { $phpcsFile->fixer->replaceToken($stackPtr, ''); } return ($lastCommentToken + 1); } if (preg_match('/^\p{Ll}/u', $commentText) === 1) { $error = 'Inline comments must start with a capital letter'; $phpcsFile->addError($error, $stackPtr, 'NotCapital'); } // Only check the end of comment character if the start of the comment // is a letter, indicating that the comment is just standard text. if (preg_match('/^\p{L}/u', $commentText) === 1) { $commentCloser = $commentText[(strlen($commentText) - 1)]; $acceptedClosers = [ 'full-stops' => '.', 'exclamation marks' => '!', 'or question marks' => '?', ]; if (in_array($commentCloser, $acceptedClosers, true) === false) { $error = 'Inline comments must end in %s'; $ender = ''; foreach ($acceptedClosers as $closerName => $symbol) { $ender .= ' '.$closerName.','; } $ender = trim($ender, ' ,'); $data = [$ender]; $phpcsFile->addError($error, $lastCommentToken, 'InvalidEndChar', $data); } } // Finally, the line below the last comment cannot be empty if this inline // comment is on a line by itself. if ($tokens[$previousContent]['line'] < $tokens[$stackPtr]['line']) { $next = $phpcsFile->findNext(T_WHITESPACE, ($lastCommentToken + 1), null, true); if ($next === false) { // Ignore if the comment is the last non-whitespace token in a file. return ($lastCommentToken + 1); } if ($tokens[$next]['code'] === T_DOC_COMMENT_OPEN_TAG) { // If this inline comment is followed by a docblock, // ignore spacing as docblock/function etc spacing rules // are likely to conflict with our rules. return ($lastCommentToken + 1); } $errorCode = 'SpacingAfter'; if (isset($tokens[$stackPtr]['conditions']) === true) { $conditions = $tokens[$stackPtr]['conditions']; $type = end($conditions); $conditionPtr = key($conditions); if (($type === T_FUNCTION || $type === T_CLOSURE) && $tokens[$conditionPtr]['scope_closer'] === $next ) { $errorCode = 'SpacingAfterAtFunctionEnd'; } } for ($i = ($lastCommentToken + 1); $i < $phpcsFile->numTokens; $i++) { if ($tokens[$i]['line'] === ($tokens[$lastCommentToken]['line'] + 1)) { if ($tokens[$i]['code'] !== T_WHITESPACE) { return ($lastCommentToken + 1); } } else if ($tokens[$i]['line'] > ($tokens[$lastCommentToken]['line'] + 1)) { break; } } $error = 'There must be no blank line following an inline comment'; $fix = $phpcsFile->addFixableError($error, $lastCommentToken, $errorCode); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($lastCommentToken + 1); $i < $next; $i++) { if ($tokens[$i]['line'] === $tokens[$next]['line']) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } }//end if return ($lastCommentToken + 1); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Commenting/LongConditionClosingCommentSniff.php0000644000076500000240000001565613614652362032616 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Commenting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class LongConditionClosingCommentSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * The openers that we are interested in. * * @var integer[] */ private static $openers = [ T_SWITCH, T_IF, T_FOR, T_FOREACH, T_WHILE, T_TRY, T_CASE, ]; /** * The length that a code block must be before * requiring a closing comment. * * @var integer */ public $lineLimit = 20; /** * The format the end comment should be in. * * The placeholder %s will be replaced with the type of condition opener. * * @var string */ public $commentFormat = '//end %s'; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_CLOSE_CURLY_BRACKET]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['scope_condition']) === false) { // No scope condition. It is a function closer. return; } $startCondition = $tokens[$tokens[$stackPtr]['scope_condition']]; $startBrace = $tokens[$tokens[$stackPtr]['scope_opener']]; $endBrace = $tokens[$stackPtr]; // We are only interested in some code blocks. if (in_array($startCondition['code'], self::$openers, true) === false) { return; } if ($startCondition['code'] === T_IF) { // If this is actually an ELSE IF, skip it as the brace // will be checked by the original IF. $else = $phpcsFile->findPrevious(T_WHITESPACE, ($tokens[$stackPtr]['scope_condition'] - 1), null, true); if ($tokens[$else]['code'] === T_ELSE) { return; } // IF statements that have an ELSE block need to use // "end if" rather than "end else" or "end elseif". do { $nextToken = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($tokens[$nextToken]['code'] === T_ELSE || $tokens[$nextToken]['code'] === T_ELSEIF) { // Check for ELSE IF (2 tokens) as opposed to ELSEIF (1 token). if ($tokens[$nextToken]['code'] === T_ELSE && isset($tokens[$nextToken]['scope_closer']) === false ) { $nextToken = $phpcsFile->findNext(T_WHITESPACE, ($nextToken + 1), null, true); if ($tokens[$nextToken]['code'] !== T_IF || isset($tokens[$nextToken]['scope_closer']) === false ) { // Not an ELSE IF or is an inline ELSE IF. break; } } if (isset($tokens[$nextToken]['scope_closer']) === false) { // There isn't going to be anywhere to print the "end if" comment // because there is no closer. return; } // The end brace becomes the ELSE's end brace. $stackPtr = $tokens[$nextToken]['scope_closer']; $endBrace = $tokens[$stackPtr]; } else { break; }//end if } while (isset($tokens[$nextToken]['scope_closer']) === true); }//end if if ($startCondition['code'] === T_TRY) { // TRY statements need to check until the end of all CATCH statements. do { $nextToken = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($tokens[$nextToken]['code'] === T_CATCH || $tokens[$nextToken]['code'] === T_FINALLY ) { // The end brace becomes the CATCH end brace. $stackPtr = $tokens[$nextToken]['scope_closer']; $endBrace = $tokens[$stackPtr]; } else { break; } } while (isset($tokens[$nextToken]['scope_closer']) === true); } $lineDifference = ($endBrace['line'] - $startBrace['line']); $expected = sprintf($this->commentFormat, $startCondition['content']); $comment = $phpcsFile->findNext([T_COMMENT], $stackPtr, null, false); if (($comment === false) || ($tokens[$comment]['line'] !== $endBrace['line'])) { if ($lineDifference >= $this->lineLimit) { $error = 'End comment for long condition not found; expected "%s"'; $data = [$expected]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Missing', $data); if ($fix === true) { $next = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($next !== false && $tokens[$next]['line'] === $tokens[$stackPtr]['line']) { $expected .= $phpcsFile->eolChar; } $phpcsFile->fixer->addContent($stackPtr, $expected); } } return; } if (($comment - $stackPtr) !== 1) { $error = 'Space found before closing comment; expected "%s"'; $data = [$expected]; $phpcsFile->addError($error, $stackPtr, 'SpacingBefore', $data); } if (trim($tokens[$comment]['content']) !== $expected) { $found = trim($tokens[$comment]['content']); $error = 'Incorrect closing comment; expected "%s" but found "%s"'; $data = [ $expected, $found, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Invalid', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken($comment, $expected.$phpcsFile->eolChar); } return; } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Commenting/PostStatementCommentSniff.php0000644000076500000240000000671413614652362031336 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Commenting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class PostStatementCommentSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * Exceptions to the rule. * * If post statement comments are found within the condition * parenthesis of these structures, leave them alone. * * @var array */ private $controlStructureExceptions = [ T_IF => true, T_ELSEIF => true, T_SWITCH => true, T_WHILE => true, T_FOR => true, T_FOREACH => true, ]; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_COMMENT]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (substr($tokens[$stackPtr]['content'], 0, 2) !== '//') { return; } $commentLine = $tokens[$stackPtr]['line']; $lastContent = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true); if ($lastContent === false || $tokens[$lastContent]['line'] !== $commentLine || $tokens[$stackPtr]['column'] === 1 ) { return; } if ($tokens[$lastContent]['code'] === T_CLOSE_CURLY_BRACKET) { return; } // Special case for JS files and PHP closures. if ($tokens[$lastContent]['code'] === T_COMMA || $tokens[$lastContent]['code'] === T_SEMICOLON ) { $lastContent = $phpcsFile->findPrevious(T_WHITESPACE, ($lastContent - 1), null, true); if ($lastContent === false || $tokens[$lastContent]['code'] === T_CLOSE_CURLY_BRACKET) { return; } } // Special case for (trailing) comments within multi-line control structures. if (isset($tokens[$stackPtr]['nested_parenthesis']) === true) { $nestedParens = $tokens[$stackPtr]['nested_parenthesis']; foreach ($nestedParens as $open => $close) { if (isset($tokens[$open]['parenthesis_owner']) === true && isset($this->controlStructureExceptions[$tokens[$tokens[$open]['parenthesis_owner']]['code']]) === true ) { return; } } } $error = 'Comments may not appear after statements'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Found'); if ($fix === true) { $phpcsFile->fixer->addNewlineBefore($stackPtr); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Commenting/VariableCommentSniff.php0000644000076500000240000001465613614652362030255 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Commenting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\AbstractVariableSniff; use PHP_CodeSniffer\Util\Common; class VariableCommentSniff extends AbstractVariableSniff { /** * Called to process class member vars. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function processMemberVar(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $ignore = [ T_PUBLIC, T_PRIVATE, T_PROTECTED, T_VAR, T_STATIC, T_WHITESPACE, T_STRING, T_NS_SEPARATOR, T_NULLABLE, ]; $commentEnd = $phpcsFile->findPrevious($ignore, ($stackPtr - 1), null, true); if ($commentEnd === false || ($tokens[$commentEnd]['code'] !== T_DOC_COMMENT_CLOSE_TAG && $tokens[$commentEnd]['code'] !== T_COMMENT) ) { $phpcsFile->addError('Missing member variable doc comment', $stackPtr, 'Missing'); return; } if ($tokens[$commentEnd]['code'] === T_COMMENT) { $phpcsFile->addError('You must use "/**" style comments for a member variable comment', $stackPtr, 'WrongStyle'); return; } $commentStart = $tokens[$commentEnd]['comment_opener']; $foundVar = null; foreach ($tokens[$commentStart]['comment_tags'] as $tag) { if ($tokens[$tag]['content'] === '@var') { if ($foundVar !== null) { $error = 'Only one @var tag is allowed in a member variable comment'; $phpcsFile->addError($error, $tag, 'DuplicateVar'); } else { $foundVar = $tag; } } else if ($tokens[$tag]['content'] === '@see') { // Make sure the tag isn't empty. $string = $phpcsFile->findNext(T_DOC_COMMENT_STRING, $tag, $commentEnd); if ($string === false || $tokens[$string]['line'] !== $tokens[$tag]['line']) { $error = 'Content missing for @see tag in member variable comment'; $phpcsFile->addError($error, $tag, 'EmptySees'); } } else { $error = '%s tag is not allowed in member variable comment'; $data = [$tokens[$tag]['content']]; $phpcsFile->addWarning($error, $tag, 'TagNotAllowed', $data); }//end if }//end foreach // The @var tag is the only one we require. if ($foundVar === null) { $error = 'Missing @var tag in member variable comment'; $phpcsFile->addError($error, $commentEnd, 'MissingVar'); return; } $firstTag = $tokens[$commentStart]['comment_tags'][0]; if ($foundVar !== null && $tokens[$firstTag]['content'] !== '@var') { $error = 'The @var tag must be the first tag in a member variable comment'; $phpcsFile->addError($error, $foundVar, 'VarOrder'); } // Make sure the tag isn't empty and has the correct padding. $string = $phpcsFile->findNext(T_DOC_COMMENT_STRING, $foundVar, $commentEnd); if ($string === false || $tokens[$string]['line'] !== $tokens[$foundVar]['line']) { $error = 'Content missing for @var tag in member variable comment'; $phpcsFile->addError($error, $foundVar, 'EmptyVar'); return; } // Support both a var type and a description. preg_match('`^((?:\|?(?:array\([^\)]*\)|[\\\\a-z0-9\[\]]+))*)( .*)?`i', $tokens[($foundVar + 2)]['content'], $varParts); if (isset($varParts[1]) === false) { return; } $varType = $varParts[1]; // Check var type (can be multiple, separated by '|'). $typeNames = explode('|', $varType); $suggestedNames = []; foreach ($typeNames as $i => $typeName) { $suggestedName = Common::suggestType($typeName); if (in_array($suggestedName, $suggestedNames, true) === false) { $suggestedNames[] = $suggestedName; } } $suggestedType = implode('|', $suggestedNames); if ($varType !== $suggestedType) { $error = 'Expected "%s" but found "%s" for @var tag in member variable comment'; $data = [ $suggestedType, $varType, ]; $fix = $phpcsFile->addFixableError($error, $foundVar, 'IncorrectVarType', $data); if ($fix === true) { $replacement = $suggestedType; if (empty($varParts[2]) === false) { $replacement .= $varParts[2]; } $phpcsFile->fixer->replaceToken(($foundVar + 2), $replacement); unset($replacement); } } }//end processMemberVar() /** * Called to process a normal variable. * * Not required for this sniff. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where this token was found. * @param int $stackPtr The position where the double quoted * string was found. * * @return void */ protected function processVariable(File $phpcsFile, $stackPtr) { }//end processVariable() /** * Called to process variables found in double quoted strings. * * Not required for this sniff. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The PHP_CodeSniffer file where this token was found. * @param int $stackPtr The position where the double quoted * string was found. * * @return void */ protected function processVariableInString(File $phpcsFile, $stackPtr) { }//end processVariableInString() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/ControlStructures/ControlSignatureSniff.php0000644000076500000240000003001613614652362032117 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\ControlStructures; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class ControlSignatureSniff implements Sniff { /** * How many spaces should precede the colon if using alternative syntax. * * @var integer */ public $requiredSpacesBeforeColon = 1; /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * Returns an array of tokens this test wants to listen for. * * @return int[] */ public function register() { return [ T_TRY, T_CATCH, T_FINALLY, T_DO, T_WHILE, T_FOR, T_IF, T_FOREACH, T_ELSE, T_ELSEIF, T_SWITCH, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true); if ($nextNonEmpty === false) { return; } $isAlternative = false; if (isset($tokens[$stackPtr]['scope_opener']) === true && $tokens[$tokens[$stackPtr]['scope_opener']]['code'] === T_COLON ) { $isAlternative = true; } // Single space after the keyword. $expected = 1; if (isset($tokens[$stackPtr]['parenthesis_closer']) === false && $isAlternative === true) { // Catching cases like: // if (condition) : ... else: ... endif // where there is no condition. $expected = (int) $this->requiredSpacesBeforeColon; } $found = 1; if ($tokens[($stackPtr + 1)]['code'] !== T_WHITESPACE) { $found = 0; } else if ($tokens[($stackPtr + 1)]['content'] !== ' ') { if (strpos($tokens[($stackPtr + 1)]['content'], $phpcsFile->eolChar) !== false) { $found = 'newline'; } else { $found = $tokens[($stackPtr + 1)]['length']; } } if ($found !== $expected) { $error = 'Expected %s space(s) after %s keyword; %s found'; $data = [ $expected, strtoupper($tokens[$stackPtr]['content']), $found, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceAfterKeyword', $data); if ($fix === true) { if ($found === 0) { $phpcsFile->fixer->addContent($stackPtr, str_repeat(' ', $expected)); } else { $phpcsFile->fixer->replaceToken(($stackPtr + 1), str_repeat(' ', $expected)); } } } // Single space after closing parenthesis. if (isset($tokens[$stackPtr]['parenthesis_closer']) === true && isset($tokens[$stackPtr]['scope_opener']) === true ) { $expected = 1; if ($isAlternative === true) { $expected = (int) $this->requiredSpacesBeforeColon; } $closer = $tokens[$stackPtr]['parenthesis_closer']; $opener = $tokens[$stackPtr]['scope_opener']; $content = $phpcsFile->getTokensAsString(($closer + 1), ($opener - $closer - 1)); if (trim($content) === '') { if (strpos($content, $phpcsFile->eolChar) !== false) { $found = 'newline'; } else { $found = strlen($content); } } else { $found = '"'.str_replace($phpcsFile->eolChar, '\n', $content).'"'; } if ($found !== $expected) { $error = 'Expected %s space(s) after closing parenthesis; found %s'; $data = [ $expected, $found, ]; $fix = $phpcsFile->addFixableError($error, $closer, 'SpaceAfterCloseParenthesis', $data); if ($fix === true) { $padding = str_repeat(' ', $expected); if ($closer === ($opener - 1)) { $phpcsFile->fixer->addContent($closer, $padding); } else { $phpcsFile->fixer->beginChangeset(); if (trim($content) === '') { $phpcsFile->fixer->addContent($closer, $padding); if ($found !== 0) { for ($i = ($closer + 1); $i < $opener; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } } } else { $phpcsFile->fixer->addContent($closer, $padding.$tokens[$opener]['content']); $phpcsFile->fixer->replaceToken($opener, ''); if ($tokens[$opener]['line'] !== $tokens[$closer]['line']) { $next = $phpcsFile->findNext(T_WHITESPACE, ($opener + 1), null, true); if ($tokens[$next]['line'] !== $tokens[$opener]['line']) { for ($i = ($opener + 1); $i < $next; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } } } } $phpcsFile->fixer->endChangeset(); }//end if }//end if }//end if }//end if // Single newline after opening brace. if (isset($tokens[$stackPtr]['scope_opener']) === true) { $opener = $tokens[$stackPtr]['scope_opener']; for ($next = ($opener + 1); $next < $phpcsFile->numTokens; $next++) { $code = $tokens[$next]['code']; if ($code === T_WHITESPACE || ($code === T_INLINE_HTML && trim($tokens[$next]['content']) === '') ) { continue; } // Skip all empty tokens on the same line as the opener. if ($tokens[$next]['line'] === $tokens[$opener]['line'] && (isset(Tokens::$emptyTokens[$code]) === true || $code === T_CLOSE_TAG) ) { continue; } // We found the first bit of a code, or a comment on the // following line. break; }//end for if ($tokens[$next]['line'] === $tokens[$opener]['line']) { $error = 'Newline required after opening brace'; $fix = $phpcsFile->addFixableError($error, $opener, 'NewlineAfterOpenBrace'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($opener + 1); $i < $next; $i++) { if (trim($tokens[$i]['content']) !== '') { break; } // Remove whitespace. $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->addContent($opener, $phpcsFile->eolChar); $phpcsFile->fixer->endChangeset(); } }//end if } else if ($tokens[$stackPtr]['code'] === T_WHILE) { // Zero spaces after parenthesis closer, but only if followed by a semicolon. $closer = $tokens[$stackPtr]['parenthesis_closer']; $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($closer + 1), null, true); if ($nextNonEmpty !== false && $tokens[$nextNonEmpty]['code'] === T_SEMICOLON) { $found = 0; if ($tokens[($closer + 1)]['code'] === T_WHITESPACE) { if (strpos($tokens[($closer + 1)]['content'], $phpcsFile->eolChar) !== false) { $found = 'newline'; } else { $found = $tokens[($closer + 1)]['length']; } } if ($found !== 0) { $error = 'Expected 0 spaces before semicolon; %s found'; $data = [$found]; $fix = $phpcsFile->addFixableError($error, $closer, 'SpaceBeforeSemicolon', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($closer + 1), ''); } } } }//end if // Only want to check multi-keyword structures from here on. if ($tokens[$stackPtr]['code'] === T_WHILE) { if (isset($tokens[$stackPtr]['scope_closer']) !== false) { return; } $closer = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); if ($closer === false || $tokens[$closer]['code'] !== T_CLOSE_CURLY_BRACKET || $tokens[$tokens[$closer]['scope_condition']]['code'] !== T_DO ) { return; } } else if ($tokens[$stackPtr]['code'] === T_ELSE || $tokens[$stackPtr]['code'] === T_ELSEIF || $tokens[$stackPtr]['code'] === T_CATCH || $tokens[$stackPtr]['code'] === T_FINALLY ) { if (isset($tokens[$stackPtr]['scope_opener']) === true && $tokens[$tokens[$stackPtr]['scope_opener']]['code'] === T_COLON ) { // Special case for alternate syntax, where this token is actually // the closer for the previous block, so there is no spacing to check. return; } $closer = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); if ($closer === false || $tokens[$closer]['code'] !== T_CLOSE_CURLY_BRACKET) { return; } } else { return; }//end if // Single space after closing brace. $found = 1; if ($tokens[($closer + 1)]['code'] !== T_WHITESPACE) { $found = 0; } else if ($tokens[$closer]['line'] !== $tokens[$stackPtr]['line']) { $found = 'newline'; } else if ($tokens[($closer + 1)]['content'] !== ' ') { $found = $tokens[($closer + 1)]['length']; } if ($found !== 1) { $error = 'Expected 1 space after closing brace; %s found'; $data = [$found]; if ($phpcsFile->findNext(Tokens::$commentTokens, ($closer + 1), $stackPtr) !== false) { // Comment found between closing brace and keyword, don't auto-fix. $phpcsFile->addError($error, $closer, 'SpaceAfterCloseBrace', $data); return; } $fix = $phpcsFile->addFixableError($error, $closer, 'SpaceAfterCloseBrace', $data); if ($fix === true) { if ($found === 0) { $phpcsFile->fixer->addContent($closer, ' '); } else { $phpcsFile->fixer->replaceToken(($closer + 1), ' '); } } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/ControlStructures/ElseIfDeclarationSniff.php0000644000076500000240000000253013614652362032132 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\ControlStructures; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class ElseIfDeclarationSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_ELSEIF]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $error = 'Usage of ELSEIF not allowed; use ELSE IF instead'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NotAllowed'); if ($fix === true) { $phpcsFile->fixer->replaceToken($stackPtr, 'else if'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/ControlStructures/ForEachLoopDeclarationSniff.php0000644000076500000240000002276113614652362033134 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\ControlStructures; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class ForEachLoopDeclarationSniff implements Sniff { /** * How many spaces should follow the opening bracket. * * @var integer */ public $requiredSpacesAfterOpen = 0; /** * How many spaces should precede the closing bracket. * * @var integer */ public $requiredSpacesBeforeClose = 0; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_FOREACH]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $this->requiredSpacesAfterOpen = (int) $this->requiredSpacesAfterOpen; $this->requiredSpacesBeforeClose = (int) $this->requiredSpacesBeforeClose; $tokens = $phpcsFile->getTokens(); $openingBracket = $phpcsFile->findNext(T_OPEN_PARENTHESIS, $stackPtr); if ($openingBracket === false) { $error = 'Possible parse error: FOREACH has no opening parenthesis'; $phpcsFile->addWarning($error, $stackPtr, 'MissingOpenParenthesis'); return; } if (isset($tokens[$openingBracket]['parenthesis_closer']) === false) { $error = 'Possible parse error: FOREACH has no closing parenthesis'; $phpcsFile->addWarning($error, $stackPtr, 'MissingCloseParenthesis'); return; } $closingBracket = $tokens[$openingBracket]['parenthesis_closer']; if ($this->requiredSpacesAfterOpen === 0 && $tokens[($openingBracket + 1)]['code'] === T_WHITESPACE) { $error = 'Space found after opening bracket of FOREACH loop'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceAfterOpen'); if ($fix === true) { $phpcsFile->fixer->replaceToken(($openingBracket + 1), ''); } } else if ($this->requiredSpacesAfterOpen > 0) { $spaceAfterOpen = 0; if ($tokens[($openingBracket + 1)]['code'] === T_WHITESPACE) { $spaceAfterOpen = $tokens[($openingBracket + 1)]['length']; } if ($spaceAfterOpen !== $this->requiredSpacesAfterOpen) { $error = 'Expected %s spaces after opening bracket; %s found'; $data = [ $this->requiredSpacesAfterOpen, $spaceAfterOpen, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpacingAfterOpen', $data); if ($fix === true) { $padding = str_repeat(' ', $this->requiredSpacesAfterOpen); if ($spaceAfterOpen === 0) { $phpcsFile->fixer->addContent($openingBracket, $padding); } else { $phpcsFile->fixer->replaceToken(($openingBracket + 1), $padding); } } } }//end if if ($this->requiredSpacesBeforeClose === 0 && $tokens[($closingBracket - 1)]['code'] === T_WHITESPACE) { $error = 'Space found before closing bracket of FOREACH loop'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceBeforeClose'); if ($fix === true) { $phpcsFile->fixer->replaceToken(($closingBracket - 1), ''); } } else if ($this->requiredSpacesBeforeClose > 0) { $spaceBeforeClose = 0; if ($tokens[($closingBracket - 1)]['code'] === T_WHITESPACE) { $spaceBeforeClose = $tokens[($closingBracket - 1)]['length']; } if ($spaceBeforeClose !== $this->requiredSpacesBeforeClose) { $error = 'Expected %s spaces before closing bracket; %s found'; $data = [ $this->requiredSpacesBeforeClose, $spaceBeforeClose, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceBeforeClose', $data); if ($fix === true) { $padding = str_repeat(' ', $this->requiredSpacesBeforeClose); if ($spaceBeforeClose === 0) { $phpcsFile->fixer->addContentBefore($closingBracket, $padding); } else { $phpcsFile->fixer->replaceToken(($closingBracket - 1), $padding); } } } }//end if $asToken = $phpcsFile->findNext(T_AS, $openingBracket); if ($asToken === false) { $error = 'Possible parse error: FOREACH has no AS statement'; $phpcsFile->addWarning($error, $stackPtr, 'MissingAs'); return; } $content = $tokens[$asToken]['content']; if ($content !== strtolower($content)) { $expected = strtolower($content); $error = 'AS keyword must be lowercase; expected "%s" but found "%s"'; $data = [ $expected, $content, ]; $fix = $phpcsFile->addFixableError($error, $asToken, 'AsNotLower', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken($asToken, $expected); } } $doubleArrow = $phpcsFile->findNext(T_DOUBLE_ARROW, $asToken, $closingBracket); if ($doubleArrow !== false) { if ($tokens[($doubleArrow - 1)]['code'] !== T_WHITESPACE) { $error = 'Expected 1 space before "=>"; 0 found'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NoSpaceBeforeArrow'); if ($fix === true) { $phpcsFile->fixer->addContentBefore($doubleArrow, ' '); } } else { if ($tokens[($doubleArrow - 1)]['length'] !== 1) { $spaces = $tokens[($doubleArrow - 1)]['length']; $error = 'Expected 1 space before "=>"; %s found'; $data = [$spaces]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpacingBeforeArrow', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($doubleArrow - 1), ' '); } } } if ($tokens[($doubleArrow + 1)]['code'] !== T_WHITESPACE) { $error = 'Expected 1 space after "=>"; 0 found'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NoSpaceAfterArrow'); if ($fix === true) { $phpcsFile->fixer->addContent($doubleArrow, ' '); } } else { if ($tokens[($doubleArrow + 1)]['length'] !== 1) { $spaces = $tokens[($doubleArrow + 1)]['length']; $error = 'Expected 1 space after "=>"; %s found'; $data = [$spaces]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpacingAfterArrow', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($doubleArrow + 1), ' '); } } } }//end if if ($tokens[($asToken - 1)]['code'] !== T_WHITESPACE) { $error = 'Expected 1 space before "as"; 0 found'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NoSpaceBeforeAs'); if ($fix === true) { $phpcsFile->fixer->addContentBefore($asToken, ' '); } } else { if ($tokens[($asToken - 1)]['length'] !== 1) { $spaces = $tokens[($asToken - 1)]['length']; $error = 'Expected 1 space before "as"; %s found'; $data = [$spaces]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpacingBeforeAs', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($asToken - 1), ' '); } } } if ($tokens[($asToken + 1)]['code'] !== T_WHITESPACE) { $error = 'Expected 1 space after "as"; 0 found'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NoSpaceAfterAs'); if ($fix === true) { $phpcsFile->fixer->addContent($asToken, ' '); } } else { if ($tokens[($asToken + 1)]['length'] !== 1) { $spaces = $tokens[($asToken + 1)]['length']; $error = 'Expected 1 space after "as"; %s found'; $data = [$spaces]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpacingAfterAs', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($asToken + 1), ' '); } } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/ControlStructures/ForLoopDeclarationSniff.php0000644000076500000240000003163713614652362032355 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\ControlStructures; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class ForLoopDeclarationSniff implements Sniff { /** * How many spaces should follow the opening bracket. * * @var integer */ public $requiredSpacesAfterOpen = 0; /** * How many spaces should precede the closing bracket. * * @var integer */ public $requiredSpacesBeforeClose = 0; /** * Allow newlines instead of spaces. * * @var boolean */ public $ignoreNewlines = false; /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_FOR]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $this->requiredSpacesAfterOpen = (int) $this->requiredSpacesAfterOpen; $this->requiredSpacesBeforeClose = (int) $this->requiredSpacesBeforeClose; $tokens = $phpcsFile->getTokens(); $openingBracket = $phpcsFile->findNext(T_OPEN_PARENTHESIS, $stackPtr); if ($openingBracket === false) { $error = 'Possible parse error: no opening parenthesis for FOR keyword'; $phpcsFile->addWarning($error, $stackPtr, 'NoOpenBracket'); return; } $closingBracket = $tokens[$openingBracket]['parenthesis_closer']; if ($this->requiredSpacesAfterOpen === 0 && $tokens[($openingBracket + 1)]['code'] === T_WHITESPACE ) { $nextNonWhiteSpace = $phpcsFile->findNext(T_WHITESPACE, ($openingBracket + 1), $closingBracket, true); if ($this->ignoreNewlines === false || $tokens[$nextNonWhiteSpace]['line'] === $tokens[$openingBracket]['line'] ) { $error = 'Whitespace found after opening bracket of FOR loop'; $fix = $phpcsFile->addFixableError($error, $openingBracket, 'SpacingAfterOpen'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($openingBracket + 1); $i < $closingBracket; $i++) { if ($tokens[$i]['code'] !== T_WHITESPACE) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } } } else if ($this->requiredSpacesAfterOpen > 0) { $nextNonWhiteSpace = $phpcsFile->findNext(T_WHITESPACE, ($openingBracket + 1), $closingBracket, true); $spaceAfterOpen = 0; if ($tokens[$openingBracket]['line'] !== $tokens[$nextNonWhiteSpace]['line']) { $spaceAfterOpen = 'newline'; } else if ($tokens[($openingBracket + 1)]['code'] === T_WHITESPACE) { $spaceAfterOpen = $tokens[($openingBracket + 1)]['length']; } if ($spaceAfterOpen !== $this->requiredSpacesAfterOpen && ($this->ignoreNewlines === false || $spaceAfterOpen !== 'newline') ) { $error = 'Expected %s spaces after opening bracket; %s found'; $data = [ $this->requiredSpacesAfterOpen, $spaceAfterOpen, ]; $fix = $phpcsFile->addFixableError($error, $openingBracket, 'SpacingAfterOpen', $data); if ($fix === true) { $padding = str_repeat(' ', $this->requiredSpacesAfterOpen); if ($spaceAfterOpen === 0) { $phpcsFile->fixer->addContent($openingBracket, $padding); } else { $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->replaceToken(($openingBracket + 1), $padding); for ($i = ($openingBracket + 2); $i < $nextNonWhiteSpace; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } } }//end if }//end if $prevNonWhiteSpace = $phpcsFile->findPrevious(T_WHITESPACE, ($closingBracket - 1), $openingBracket, true); $beforeClosefixable = true; if ($tokens[$prevNonWhiteSpace]['line'] !== $tokens[$closingBracket]['line'] && isset(Tokens::$emptyTokens[$tokens[$prevNonWhiteSpace]['code']]) === true ) { $beforeClosefixable = false; } if ($this->requiredSpacesBeforeClose === 0 && $tokens[($closingBracket - 1)]['code'] === T_WHITESPACE && ($this->ignoreNewlines === false || $tokens[$prevNonWhiteSpace]['line'] === $tokens[$closingBracket]['line']) ) { $error = 'Whitespace found before closing bracket of FOR loop'; if ($beforeClosefixable === false) { $phpcsFile->addError($error, $closingBracket, 'SpacingBeforeClose'); } else { $fix = $phpcsFile->addFixableError($error, $closingBracket, 'SpacingBeforeClose'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($closingBracket - 1); $i > $openingBracket; $i--) { if ($tokens[$i]['code'] !== T_WHITESPACE) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } } } else if ($this->requiredSpacesBeforeClose > 0) { $spaceBeforeClose = 0; if ($tokens[$closingBracket]['line'] !== $tokens[$prevNonWhiteSpace]['line']) { $spaceBeforeClose = 'newline'; } else if ($tokens[($closingBracket - 1)]['code'] === T_WHITESPACE) { $spaceBeforeClose = $tokens[($closingBracket - 1)]['length']; } if ($this->requiredSpacesBeforeClose !== $spaceBeforeClose && ($this->ignoreNewlines === false || $spaceBeforeClose !== 'newline') ) { $error = 'Expected %s spaces before closing bracket; %s found'; $data = [ $this->requiredSpacesBeforeClose, $spaceBeforeClose, ]; if ($beforeClosefixable === false) { $phpcsFile->addError($error, $closingBracket, 'SpacingBeforeClose', $data); } else { $fix = $phpcsFile->addFixableError($error, $closingBracket, 'SpacingBeforeClose', $data); if ($fix === true) { $padding = str_repeat(' ', $this->requiredSpacesBeforeClose); if ($spaceBeforeClose === 0) { $phpcsFile->fixer->addContentBefore($closingBracket, $padding); } else { $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->replaceToken(($closingBracket - 1), $padding); for ($i = ($closingBracket - 2); $i > $prevNonWhiteSpace; $i--) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } } } }//end if }//end if /* * Check whitespace around each of the semicolon tokens. */ $semicolonCount = 0; $semicolon = $openingBracket; $targetNestinglevel = 0; if (isset($tokens[$openingBracket]['conditions']) === true) { $targetNestinglevel += count($tokens[$openingBracket]['conditions']); } do { $semicolon = $phpcsFile->findNext(T_SEMICOLON, ($semicolon + 1), $closingBracket); if ($semicolon === false) { break; } if (isset($tokens[$semicolon]['conditions']) === true && count($tokens[$semicolon]['conditions']) > $targetNestinglevel ) { // Semicolon doesn't belong to the for(). continue; } ++$semicolonCount; $humanReadableCount = 'first'; if ($semicolonCount !== 1) { $humanReadableCount = 'second'; } $humanReadableCode = ucfirst($humanReadableCount); $data = [$humanReadableCount]; // Only examine the space before the first semicolon if the first expression is not empty. // If it *is* empty, leave it up to the `SpacingAfterOpen` logic. $prevNonWhiteSpace = $phpcsFile->findPrevious(T_WHITESPACE, ($semicolon - 1), $openingBracket, true); if ($semicolonCount !== 1 || $prevNonWhiteSpace !== $openingBracket) { if ($tokens[($semicolon - 1)]['code'] === T_WHITESPACE) { $error = 'Whitespace found before %s semicolon of FOR loop'; $errorCode = 'SpacingBefore'.$humanReadableCode; $fix = $phpcsFile->addFixableError($error, $semicolon, $errorCode, $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($semicolon - 1); $i > $prevNonWhiteSpace; $i--) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } } } // Only examine the space after the second semicolon if the last expression is not empty. // If it *is* empty, leave it up to the `SpacingBeforeClose` logic. $nextNonWhiteSpace = $phpcsFile->findNext(T_WHITESPACE, ($semicolon + 1), ($closingBracket + 1), true); if ($semicolonCount !== 2 || $nextNonWhiteSpace !== $closingBracket) { if ($tokens[($semicolon + 1)]['code'] !== T_WHITESPACE && $tokens[($semicolon + 1)]['code'] !== T_SEMICOLON ) { $error = 'Expected 1 space after %s semicolon of FOR loop; 0 found'; $errorCode = 'NoSpaceAfter'.$humanReadableCode; $fix = $phpcsFile->addFixableError($error, $semicolon, $errorCode, $data); if ($fix === true) { $phpcsFile->fixer->addContent($semicolon, ' '); } } else if ($tokens[($semicolon + 1)]['code'] === T_WHITESPACE && $tokens[$nextNonWhiteSpace]['code'] !== T_SEMICOLON ) { $spaces = $tokens[($semicolon + 1)]['length']; if ($tokens[$semicolon]['line'] !== $tokens[$nextNonWhiteSpace]['line']) { $spaces = 'newline'; } if ($spaces !== 1 && ($this->ignoreNewlines === false || $spaces !== 'newline') ) { $error = 'Expected 1 space after %s semicolon of FOR loop; %s found'; $errorCode = 'SpacingAfter'.$humanReadableCode; $data[] = $spaces; $fix = $phpcsFile->addFixableError($error, $semicolon, $errorCode, $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->replaceToken(($semicolon + 1), ' '); for ($i = ($semicolon + 2); $i < $nextNonWhiteSpace; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } } }//end if }//end if } while ($semicolonCount < 2); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/ControlStructures/InlineIfDeclarationSniff.php0000644000076500000240000001531213614652362032462 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\ControlStructures; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class InlineIfDeclarationSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_INLINE_THEN]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $openBracket = null; $closeBracket = null; if (isset($tokens[$stackPtr]['nested_parenthesis']) === true) { $parens = $tokens[$stackPtr]['nested_parenthesis']; $openBracket = array_pop($parens); $closeBracket = $tokens[$openBracket]['parenthesis_closer']; } // Find the beginning of the statement. If we don't find a // semicolon (end of statement) or comma (end of array value) // then assume the content before the closing parenthesis is the end. $else = $phpcsFile->findNext(T_INLINE_ELSE, ($stackPtr + 1)); $statementEnd = $phpcsFile->findNext([T_SEMICOLON, T_COMMA], ($else + 1), $closeBracket); if ($statementEnd === false) { $statementEnd = $phpcsFile->findPrevious(T_WHITESPACE, ($closeBracket - 1), null, true); } // Make sure it's all on the same line. if ($tokens[$statementEnd]['line'] !== $tokens[$stackPtr]['line']) { $error = 'Inline shorthand IF statement must be declared on a single line'; $phpcsFile->addError($error, $stackPtr, 'NotSingleLine'); return; } // Make sure there are spaces around the question mark. $contentBefore = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true); $contentAfter = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($tokens[$contentBefore]['code'] !== T_CLOSE_PARENTHESIS) { $error = 'Inline shorthand IF statement requires brackets around comparison'; $phpcsFile->addError($error, $stackPtr, 'NoBrackets'); } $spaceBefore = ($tokens[$stackPtr]['column'] - ($tokens[$contentBefore]['column'] + $tokens[$contentBefore]['length'])); if ($spaceBefore !== 1) { $error = 'Inline shorthand IF statement requires 1 space before THEN; %s found'; $data = [$spaceBefore]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpacingBeforeThen', $data); if ($fix === true) { if ($spaceBefore === 0) { $phpcsFile->fixer->addContentBefore($stackPtr, ' '); } else { $phpcsFile->fixer->replaceToken(($stackPtr - 1), ' '); } } } // If there is no content between the ? and the : operators, then they are // trying to replicate an elvis operator, even though PHP doesn't have one. // In this case, we want no spaces between the two operators so ?: looks like // an operator itself. $next = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($tokens[$next]['code'] === T_INLINE_ELSE) { $inlineElse = $next; if ($inlineElse !== ($stackPtr + 1)) { $error = 'Inline shorthand IF statement without THEN statement requires 0 spaces between THEN and ELSE'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'ElvisSpacing'); if ($fix === true) { $phpcsFile->fixer->replaceToken(($stackPtr + 1), ''); } } } else { $spaceAfter = (($tokens[$contentAfter]['column']) - ($tokens[$stackPtr]['column'] + 1)); if ($spaceAfter !== 1) { $error = 'Inline shorthand IF statement requires 1 space after THEN; %s found'; $data = [$spaceAfter]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpacingAfterThen', $data); if ($fix === true) { if ($spaceAfter === 0) { $phpcsFile->fixer->addContent($stackPtr, ' '); } else { $phpcsFile->fixer->replaceToken(($stackPtr + 1), ' '); } } } // Make sure the ELSE has the correct spacing. $inlineElse = $phpcsFile->findNext(T_INLINE_ELSE, ($stackPtr + 1), $statementEnd, false); $contentBefore = $phpcsFile->findPrevious(T_WHITESPACE, ($inlineElse - 1), null, true); $spaceBefore = ($tokens[$inlineElse]['column'] - ($tokens[$contentBefore]['column'] + $tokens[$contentBefore]['length'])); if ($spaceBefore !== 1) { $error = 'Inline shorthand IF statement requires 1 space before ELSE; %s found'; $data = [$spaceBefore]; $fix = $phpcsFile->addFixableError($error, $inlineElse, 'SpacingBeforeElse', $data); if ($fix === true) { if ($spaceBefore === 0) { $phpcsFile->fixer->addContentBefore($inlineElse, ' '); } else { $phpcsFile->fixer->replaceToken(($inlineElse - 1), ' '); } } } }//end if $contentAfter = $phpcsFile->findNext(T_WHITESPACE, ($inlineElse + 1), null, true); $spaceAfter = (($tokens[$contentAfter]['column']) - ($tokens[$inlineElse]['column'] + 1)); if ($spaceAfter !== 1) { $error = 'Inline shorthand IF statement requires 1 space after ELSE; %s found'; $data = [$spaceAfter]; $fix = $phpcsFile->addFixableError($error, $inlineElse, 'SpacingAfterElse', $data); if ($fix === true) { if ($spaceAfter === 0) { $phpcsFile->fixer->addContent($inlineElse, ' '); } else { $phpcsFile->fixer->replaceToken(($inlineElse + 1), ' '); } } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/ControlStructures/LowercaseDeclarationSniff.php0000644000076500000240000000363413614652362032715 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\ControlStructures; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class LowercaseDeclarationSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_IF, T_ELSE, T_ELSEIF, T_FOREACH, T_FOR, T_DO, T_SWITCH, T_WHILE, T_TRY, T_CATCH, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $content = $tokens[$stackPtr]['content']; $contentLc = strtolower($content); if ($content !== $contentLc) { $error = '%s keyword must be lowercase; expected "%s" but found "%s"'; $data = [ strtoupper($content), $contentLc, $content, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'FoundUppercase', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken($stackPtr, $contentLc); } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/ControlStructures/SwitchDeclarationSniff.php0000644000076500000240000003231713614652362032232 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\ControlStructures; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class SwitchDeclarationSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * The number of spaces code should be indented. * * @var integer */ public $indent = 4; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_SWITCH]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // We can't process SWITCH statements unless we know where they start and end. if (isset($tokens[$stackPtr]['scope_opener']) === false || isset($tokens[$stackPtr]['scope_closer']) === false ) { return; } $switch = $tokens[$stackPtr]; $nextCase = $stackPtr; $caseAlignment = ($switch['column'] + $this->indent); $caseCount = 0; $foundDefault = false; while (($nextCase = $phpcsFile->findNext([T_CASE, T_DEFAULT, T_SWITCH], ($nextCase + 1), $switch['scope_closer'])) !== false) { // Skip nested SWITCH statements; they are handled on their own. if ($tokens[$nextCase]['code'] === T_SWITCH) { $nextCase = $tokens[$nextCase]['scope_closer']; continue; } if ($tokens[$nextCase]['code'] === T_DEFAULT) { $type = 'Default'; $foundDefault = true; } else { $type = 'Case'; $caseCount++; } if ($tokens[$nextCase]['content'] !== strtolower($tokens[$nextCase]['content'])) { $expected = strtolower($tokens[$nextCase]['content']); $error = strtoupper($type).' keyword must be lowercase; expected "%s" but found "%s"'; $data = [ $expected, $tokens[$nextCase]['content'], ]; $fix = $phpcsFile->addFixableError($error, $nextCase, $type.'NotLower', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken($nextCase, $expected); } } if ($tokens[$nextCase]['column'] !== $caseAlignment) { $error = strtoupper($type).' keyword must be indented '.$this->indent.' spaces from SWITCH keyword'; $fix = $phpcsFile->addFixableError($error, $nextCase, $type.'Indent'); if ($fix === true) { $padding = str_repeat(' ', ($caseAlignment - 1)); if ($tokens[$nextCase]['column'] === 1 || $tokens[($nextCase - 1)]['code'] !== T_WHITESPACE ) { $phpcsFile->fixer->addContentBefore($nextCase, $padding); } else { $phpcsFile->fixer->replaceToken(($nextCase - 1), $padding); } } } if ($type === 'Case' && ($tokens[($nextCase + 1)]['type'] !== 'T_WHITESPACE' || $tokens[($nextCase + 1)]['content'] !== ' ') ) { $error = 'CASE keyword must be followed by a single space'; $fix = $phpcsFile->addFixableError($error, $nextCase, 'SpacingAfterCase'); if ($fix === true) { if ($tokens[($nextCase + 1)]['type'] !== 'T_WHITESPACE') { $phpcsFile->fixer->addContent($nextCase, ' '); } else { $phpcsFile->fixer->replaceToken(($nextCase + 1), ' '); } } } if (isset($tokens[$nextCase]['scope_opener']) === false) { $error = 'Possible parse error: CASE missing opening colon'; $phpcsFile->addWarning($error, $nextCase, 'MissingColon'); continue; } $opener = $tokens[$nextCase]['scope_opener']; if ($tokens[($opener - 1)]['type'] === 'T_WHITESPACE') { $error = 'There must be no space before the colon in a '.strtoupper($type).' statement'; $fix = $phpcsFile->addFixableError($error, $nextCase, 'SpaceBeforeColon'.$type); if ($fix === true) { $phpcsFile->fixer->replaceToken(($opener - 1), ''); } } $nextBreak = $tokens[$nextCase]['scope_closer']; if ($tokens[$nextBreak]['code'] === T_BREAK || $tokens[$nextBreak]['code'] === T_RETURN || $tokens[$nextBreak]['code'] === T_CONTINUE || $tokens[$nextBreak]['code'] === T_THROW || $tokens[$nextBreak]['code'] === T_EXIT ) { if ($tokens[$nextBreak]['scope_condition'] === $nextCase) { // Only need to check a couple of things once, even if the // break is shared between multiple case statements, or even // the default case. if ($tokens[$nextBreak]['column'] !== $caseAlignment) { $error = 'Case breaking statement must be indented '.$this->indent.' spaces from SWITCH keyword'; $fix = $phpcsFile->addFixableError($error, $nextBreak, 'BreakIndent'); if ($fix === true) { $padding = str_repeat(' ', ($caseAlignment - 1)); if ($tokens[$nextBreak]['column'] === 1 || $tokens[($nextBreak - 1)]['code'] !== T_WHITESPACE ) { $phpcsFile->fixer->addContentBefore($nextBreak, $padding); } else { $phpcsFile->fixer->replaceToken(($nextBreak - 1), $padding); } } } $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($nextBreak - 1), $stackPtr, true); if ($tokens[$prev]['line'] !== ($tokens[$nextBreak]['line'] - 1)) { $error = 'Blank lines are not allowed before case breaking statements'; $phpcsFile->addError($error, $nextBreak, 'SpacingBeforeBreak'); } $nextLine = $tokens[$tokens[$stackPtr]['scope_closer']]['line']; $semicolon = $phpcsFile->findEndOfStatement($nextBreak); for ($i = ($semicolon + 1); $i < $tokens[$stackPtr]['scope_closer']; $i++) { if ($tokens[$i]['type'] !== 'T_WHITESPACE') { $nextLine = $tokens[$i]['line']; break; } } if ($type === 'Case') { // Ensure the BREAK statement is followed by // a single blank line, or the end switch brace. if ($nextLine !== ($tokens[$semicolon]['line'] + 2) && $i !== $tokens[$stackPtr]['scope_closer']) { $error = 'Case breaking statements must be followed by a single blank line'; $fix = $phpcsFile->addFixableError($error, $nextBreak, 'SpacingAfterBreak'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($semicolon + 1); $i <= $tokens[$stackPtr]['scope_closer']; $i++) { if ($tokens[$i]['line'] === $nextLine) { $phpcsFile->fixer->addNewlineBefore($i); break; } if ($tokens[$i]['line'] === $tokens[$semicolon]['line']) { continue; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } }//end if } else { // Ensure the BREAK statement is not followed by a blank line. if ($nextLine !== ($tokens[$semicolon]['line'] + 1)) { $error = 'Blank lines are not allowed after the DEFAULT case\'s breaking statement'; $phpcsFile->addError($error, $nextBreak, 'SpacingAfterDefaultBreak'); } }//end if $caseLine = $tokens[$nextCase]['line']; $nextLine = $tokens[$nextBreak]['line']; for ($i = ($opener + 1); $i < $nextBreak; $i++) { if ($tokens[$i]['type'] !== 'T_WHITESPACE') { $nextLine = $tokens[$i]['line']; break; } } if ($nextLine !== ($caseLine + 1)) { $error = 'Blank lines are not allowed after '.strtoupper($type).' statements'; $phpcsFile->addError($error, $nextCase, 'SpacingAfter'.$type); } }//end if if ($tokens[$nextBreak]['code'] === T_BREAK) { if ($type === 'Case') { // Ensure empty CASE statements are not allowed. // They must have some code content in them. A comment is not enough. // But count RETURN statements as valid content if they also // happen to close the CASE statement. $foundContent = false; for ($i = ($tokens[$nextCase]['scope_opener'] + 1); $i < $nextBreak; $i++) { if ($tokens[$i]['code'] === T_CASE) { $i = $tokens[$i]['scope_opener']; continue; } if (isset(Tokens::$emptyTokens[$tokens[$i]['code']]) === false) { $foundContent = true; break; } } if ($foundContent === false) { $error = 'Empty CASE statements are not allowed'; $phpcsFile->addError($error, $nextCase, 'EmptyCase'); } } else { // Ensure empty DEFAULT statements are not allowed. // They must (at least) have a comment describing why // the default case is being ignored. $foundContent = false; for ($i = ($tokens[$nextCase]['scope_opener'] + 1); $i < $nextBreak; $i++) { if ($tokens[$i]['type'] !== 'T_WHITESPACE') { $foundContent = true; break; } } if ($foundContent === false) { $error = 'Comment required for empty DEFAULT case'; $phpcsFile->addError($error, $nextCase, 'EmptyDefault'); } }//end if }//end if } else if ($type === 'Default') { $error = 'DEFAULT case must have a breaking statement'; $phpcsFile->addError($error, $nextCase, 'DefaultNoBreak'); }//end if }//end while if ($foundDefault === false) { $error = 'All SWITCH statements must contain a DEFAULT case'; $phpcsFile->addError($error, $stackPtr, 'MissingDefault'); } if ($tokens[$switch['scope_closer']]['column'] !== $switch['column']) { $error = 'Closing brace of SWITCH statement must be aligned with SWITCH keyword'; $phpcsFile->addError($error, $switch['scope_closer'], 'CloseBraceAlign'); } if ($caseCount === 0) { $error = 'SWITCH statements must contain at least one CASE statement'; $phpcsFile->addError($error, $stackPtr, 'MissingCase'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/CSS/ClassDefinitionClosingBraceSpaceSniff.php0000644000076500000240000001101713614652362032027 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\CSS; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class ClassDefinitionClosingBraceSpaceSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['CSS']; /** * Returns the token types that this sniff is interested in. * * @return int[] */ public function register() { return [T_CLOSE_CURLY_BRACKET]; }//end register() /** * Processes the tokens that this sniff is interested in. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $next = $stackPtr; while (true) { $next = $phpcsFile->findNext(T_WHITESPACE, ($next + 1), null, true); if ($next === false) { return; } if (isset(Tokens::$emptyTokens[$tokens[$next]['code']]) === true && $tokens[$next]['line'] === $tokens[$stackPtr]['line'] ) { // Trailing comment. continue; } break; } if ($tokens[$next]['code'] !== T_CLOSE_TAG) { $found = (($tokens[$next]['line'] - $tokens[$stackPtr]['line']) - 1); if ($found !== 1) { $error = 'Expected one blank line after closing brace of class definition; %s found'; $data = [max(0, $found)]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpacingAfterClose', $data); if ($fix === true) { $firstOnLine = $next; while ($tokens[$firstOnLine]['column'] !== 1) { --$firstOnLine; } if ($found < 0) { // Next statement on same line as the closing brace. $phpcsFile->fixer->addContentBefore($next, $phpcsFile->eolChar.$phpcsFile->eolChar); } else if ($found === 0) { // Next statement on next line, no blank line. $phpcsFile->fixer->addContentBefore($firstOnLine, $phpcsFile->eolChar); } else { // Too many blank lines. $phpcsFile->fixer->beginChangeset(); for ($i = ($firstOnLine - 1); $i > $stackPtr; $i--) { if ($tokens[$i]['code'] !== T_WHITESPACE) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->addContentBefore($firstOnLine, $phpcsFile->eolChar.$phpcsFile->eolChar); $phpcsFile->fixer->endChangeset(); } }//end if }//end if }//end if // Ignore nested style definitions from here on. The spacing before the closing brace // (a single blank line) will be enforced by the above check, which ensures there is a // blank line after the last nested class. $found = $phpcsFile->findPrevious( T_CLOSE_CURLY_BRACKET, ($stackPtr - 1), $tokens[$stackPtr]['bracket_opener'] ); if ($found !== false) { return; } $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); if ($prev === false) { return; } if ($tokens[$prev]['line'] === $tokens[$stackPtr]['line']) { $error = 'Closing brace of class definition must be on new line'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'ContentBeforeClose'); if ($fix === true) { $phpcsFile->fixer->addNewlineBefore($stackPtr); } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/CSS/ClassDefinitionNameSpacingSniff.php0000644000076500000240000000660613614652362030715 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\CSS; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class ClassDefinitionNameSpacingSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['CSS']; /** * Returns the token types that this sniff is interested in. * * @return int[] */ public function register() { return [T_OPEN_CURLY_BRACKET]; }//end register() /** * Processes the tokens that this sniff is interested in. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['bracket_closer']) === false) { // Syntax error or live coding, bow out. return; } // Do not check nested style definitions as, for example, in @media style rules. $nested = $phpcsFile->findNext(T_OPEN_CURLY_BRACKET, ($stackPtr + 1), $tokens[$stackPtr]['bracket_closer']); if ($nested !== false) { return; } // Find the first blank line before this opening brace, unless we get // to another style definition, comment or the start of the file. $endTokens = [ T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET, T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET, T_OPEN_TAG => T_OPEN_TAG, ]; $endTokens += Tokens::$commentTokens; $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); $foundContent = false; $currentLine = $tokens[$prev]['line']; for ($i = ($stackPtr - 1); $i >= 0; $i--) { if (isset($endTokens[$tokens[$i]['code']]) === true) { break; } if ($tokens[$i]['line'] === $currentLine) { if ($tokens[$i]['code'] !== T_WHITESPACE) { $foundContent = true; } continue; } // We changed lines. if ($foundContent === false) { // Before we throw an error, make sure we are not looking // at a gap before the style definition. $prev = $phpcsFile->findPrevious(T_WHITESPACE, $i, null, true); if ($prev !== false && isset($endTokens[$tokens[$prev]['code']]) === false ) { $error = 'Blank lines are not allowed between class names'; $phpcsFile->addError($error, ($i + 1), 'BlankLinesFound'); } break; } $foundContent = false; $currentLine = $tokens[$i]['line']; }//end for }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/CSS/ClassDefinitionOpeningBraceSpaceSniff.php0000644000076500000240000001502713614652362032035 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\CSS; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class ClassDefinitionOpeningBraceSpaceSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['CSS']; /** * Returns the token types that this sniff is interested in. * * @return int[] */ public function register() { return [T_OPEN_CURLY_BRACKET]; }//end register() /** * Processes the tokens that this sniff is interested in. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $prevNonWhitespace = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true); if ($prevNonWhitespace !== false) { $length = 0; if ($tokens[$stackPtr]['line'] !== $tokens[$prevNonWhitespace]['line']) { $length = 'newline'; } else if ($tokens[($stackPtr - 1)]['code'] === T_WHITESPACE) { if (strpos($tokens[($stackPtr - 1)]['content'], "\t") !== false) { $length = 'tab'; } else { $length = $tokens[($stackPtr - 1)]['length']; } } if ($length === 0) { $error = 'Expected 1 space before opening brace of class definition; 0 found'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NoneBefore'); if ($fix === true) { $phpcsFile->fixer->addContentBefore($stackPtr, ' '); } } else if ($length !== 1) { $error = 'Expected 1 space before opening brace of class definition; %s found'; $data = [$length]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Before', $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($stackPtr - 1); $i > $prevNonWhitespace; $i--) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->addContentBefore($stackPtr, ' '); $phpcsFile->fixer->endChangeset(); } }//end if }//end if $nextNonEmpty = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true); if ($nextNonEmpty === false) { return; } if ($tokens[$nextNonEmpty]['line'] === $tokens[$stackPtr]['line']) { $error = 'Opening brace should be the last content on the line'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'ContentBefore'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->addNewline($stackPtr); // Remove potentially left over trailing whitespace. if ($tokens[($stackPtr + 1)]['code'] === T_WHITESPACE) { $phpcsFile->fixer->replaceToken(($stackPtr + 1), ''); } $phpcsFile->fixer->endChangeset(); } } else { if (isset($tokens[$stackPtr]['bracket_closer']) === false) { // Syntax error or live coding, bow out. return; } // Check for nested class definitions. $found = $phpcsFile->findNext( T_OPEN_CURLY_BRACKET, ($stackPtr + 1), $tokens[$stackPtr]['bracket_closer'] ); if ($found === false) { // Not nested. return; } $lastOnLine = $stackPtr; for ($lastOnLine; $lastOnLine < $tokens[$stackPtr]['bracket_closer']; $lastOnLine++) { if ($tokens[$lastOnLine]['line'] !== $tokens[($lastOnLine + 1)]['line']) { break; } } $nextNonWhiteSpace = $phpcsFile->findNext(T_WHITESPACE, ($lastOnLine + 1), null, true); if ($nextNonWhiteSpace === false) { return; } $foundLines = ($tokens[$nextNonWhiteSpace]['line'] - $tokens[$stackPtr]['line'] - 1); if ($foundLines !== 1) { $error = 'Expected 1 blank line after opening brace of nesting class definition; %s found'; $data = [max(0, $foundLines)]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'AfterNesting', $data); if ($fix === true) { $firstOnNextLine = $nextNonWhiteSpace; while ($tokens[$firstOnNextLine]['column'] !== 1) { --$firstOnNextLine; } if ($found < 0) { // First statement on same line as the opening brace. $phpcsFile->fixer->addContentBefore($nextNonWhiteSpace, $phpcsFile->eolChar.$phpcsFile->eolChar); } else if ($found === 0) { // Next statement on next line, no blank line. $phpcsFile->fixer->addNewlineBefore($firstOnNextLine); } else { // Too many blank lines. $phpcsFile->fixer->beginChangeset(); for ($i = ($firstOnNextLine - 1); $i > $stackPtr; $i--) { if ($tokens[$i]['code'] !== T_WHITESPACE) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->addContentBefore($firstOnNextLine, $phpcsFile->eolChar.$phpcsFile->eolChar); $phpcsFile->fixer->endChangeset(); } }//end if }//end if }//end if }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/CSS/ColonSpacingSniff.php0000644000076500000240000000703013614652362026100 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\CSS; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class ColonSpacingSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['CSS']; /** * Returns the token types that this sniff is interested in. * * @return int[] */ public function register() { return [T_COLON]; }//end register() /** * Processes the tokens that this sniff is interested in. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); if ($tokens[$prev]['code'] !== T_STYLE) { // The colon is not part of a style definition. return; } if ($tokens[$prev]['content'] === 'progid') { // Special case for IE filters. return; } if ($tokens[($stackPtr - 1)]['code'] === T_WHITESPACE) { $error = 'There must be no space before a colon in a style definition'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Before'); if ($fix === true) { $phpcsFile->fixer->replaceToken(($stackPtr - 1), ''); } } $next = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($tokens[$next]['code'] === T_SEMICOLON || $tokens[$next]['code'] === T_STYLE) { // Empty style definition, ignore it. return; } if ($tokens[($stackPtr + 1)]['code'] !== T_WHITESPACE) { $error = 'Expected 1 space after colon in style definition; 0 found'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NoneAfter'); if ($fix === true) { $phpcsFile->fixer->addContent($stackPtr, ' '); } } else { $content = $tokens[($stackPtr + 1)]['content']; if (strpos($content, $phpcsFile->eolChar) === false) { $length = strlen($content); if ($length !== 1) { $error = 'Expected 1 space after colon in style definition; %s found'; $data = [$length]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'After', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($stackPtr + 1), ' '); } } } else { $error = 'Expected 1 space after colon in style definition; newline found'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'AfterNewline'); if ($fix === true) { $phpcsFile->fixer->replaceToken(($stackPtr + 1), ' '); } } }//end if }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/CSS/ColourDefinitionSniff.php0000644000076500000240000000472013614652362027000 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\CSS; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class ColourDefinitionSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['CSS']; /** * Returns the token types that this sniff is interested in. * * @return int[] */ public function register() { return [T_COLOUR]; }//end register() /** * Processes the tokens that this sniff is interested in. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $colour = $tokens[$stackPtr]['content']; $expected = strtoupper($colour); if ($colour !== $expected) { $error = 'CSS colours must be defined in uppercase; expected %s but found %s'; $data = [ $expected, $colour, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NotUpper', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken($stackPtr, $expected); } } // Now check if shorthand can be used. if (strlen($colour) !== 7) { return; } if ($colour[1] === $colour[2] && $colour[3] === $colour[4] && $colour[5] === $colour[6]) { $expected = '#'.$colour[1].$colour[3].$colour[5]; $error = 'CSS colours must use shorthand if available; expected %s but found %s'; $data = [ $expected, $colour, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Shorthand', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken($stackPtr, $expected); } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/CSS/DisallowMultipleStyleDefinitionsSniff.php0000644000076500000240000000354613614652362032240 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\CSS; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class DisallowMultipleStyleDefinitionsSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['CSS']; /** * Returns the token types that this sniff is interested in. * * @return int[] */ public function register() { return [T_STYLE]; }//end register() /** * Processes the tokens that this sniff is interested in. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $next = $phpcsFile->findNext(T_STYLE, ($stackPtr + 1)); if ($next === false) { return; } if ($tokens[$next]['content'] === 'progid') { // Special case for IE filters. return; } if ($tokens[$next]['line'] === $tokens[$stackPtr]['line']) { $error = 'Each style definition must be on a line by itself'; $fix = $phpcsFile->addFixableError($error, $next, 'Found'); if ($fix === true) { $phpcsFile->fixer->addNewlineBefore($next); } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/CSS/DuplicateClassDefinitionSniff.php0000644000076500000240000000701213614652362030432 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\CSS; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class DuplicateClassDefinitionSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['CSS']; /** * Returns the token types that this sniff is interested in. * * @return int[] */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes the tokens that this sniff is interested in. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Find the content of each class definition name. $classNames = []; $next = $phpcsFile->findNext(T_OPEN_CURLY_BRACKET, ($stackPtr + 1)); if ($next === false) { // No class definitions in the file. return; } // Save the class names in a "scope", // to prevent false positives with @media blocks. $scope = 'main'; $find = [ T_CLOSE_CURLY_BRACKET, T_OPEN_CURLY_BRACKET, T_OPEN_TAG, ]; while ($next !== false) { $prev = $phpcsFile->findPrevious($find, ($next - 1)); // Check if an inner block was closed. $beforePrev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($prev - 1), null, true); if ($beforePrev !== false && $tokens[$beforePrev]['code'] === T_CLOSE_CURLY_BRACKET ) { $scope = 'main'; } // Create a sorted name for the class so we can compare classes // even when the individual names are all over the place. $name = ''; for ($i = ($prev + 1); $i < $next; $i++) { $name .= $tokens[$i]['content']; } $name = trim($name); $name = str_replace("\n", ' ', $name); $name = preg_replace('|[\s]+|', ' ', $name); $name = preg_replace('|\s*/\*.*\*/\s*|', '', $name); $name = str_replace(', ', ',', $name); $names = explode(',', $name); sort($names); $name = implode(',', $names); if ($name[0] === '@') { // Media block has its own "scope". $scope = $name; } else if (isset($classNames[$scope][$name]) === true) { $first = $classNames[$scope][$name]; $error = 'Duplicate class definition found; first defined on line %s'; $data = [$tokens[$first]['line']]; $phpcsFile->addError($error, $next, 'Found', $data); } else { $classNames[$scope][$name] = $next; } $next = $phpcsFile->findNext(T_OPEN_CURLY_BRACKET, ($next + 1)); }//end while }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/CSS/DuplicateStyleDefinitionSniff.php0000644000076500000240000000467113614652362030475 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\CSS; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class DuplicateStyleDefinitionSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['CSS']; /** * Returns the token types that this sniff is interested in. * * @return int[] */ public function register() { return [T_OPEN_CURLY_BRACKET]; }//end register() /** * Processes the tokens that this sniff is interested in. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['bracket_closer']) === false) { // Syntax error or live coding, bow out. return; } // Find the content of each style definition name. $styleNames = []; $next = $stackPtr; $end = $tokens[$stackPtr]['bracket_closer']; do { $next = $phpcsFile->findNext([T_STYLE, T_OPEN_CURLY_BRACKET], ($next + 1), $end); if ($next === false) { // Class definition is empty. break; } if ($tokens[$next]['code'] === T_OPEN_CURLY_BRACKET) { $next = $tokens[$next]['bracket_closer']; continue; } $name = $tokens[$next]['content']; if (isset($styleNames[$name]) === true) { $first = $styleNames[$name]; $error = 'Duplicate style definition found; first defined on line %s'; $data = [$tokens[$first]['line']]; $phpcsFile->addError($error, $next, 'Found', $data); } else { $styleNames[$name] = $next; } } while ($next !== false); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/CSS/EmptyClassDefinitionSniff.php0000644000076500000240000000312513614652362027617 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\CSS; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class EmptyClassDefinitionSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['CSS']; /** * Returns the token types that this sniff is interested in. * * @return int[] */ public function register() { return [T_OPEN_CURLY_BRACKET]; }//end register() /** * Processes the tokens that this sniff is interested in. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true); if ($next === false || $tokens[$next]['code'] === T_CLOSE_CURLY_BRACKET) { $error = 'Class definition is empty'; $phpcsFile->addError($error, $stackPtr, 'Found'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/CSS/EmptyStyleDefinitionSniff.php0000644000076500000240000000326013614652362027652 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\CSS; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class EmptyStyleDefinitionSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['CSS']; /** * Returns the token types that this sniff is interested in. * * @return int[] */ public function register() { return [T_STYLE]; }//end register() /** * Processes the tokens that this sniff is interested in. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $ignore = Tokens::$emptyTokens; $ignore[] = T_COLON; $next = $phpcsFile->findNext($ignore, ($stackPtr + 1), null, true); if ($next === false || $tokens[$next]['code'] === T_SEMICOLON || $tokens[$next]['line'] !== $tokens[$stackPtr]['line']) { $error = 'Style definition is empty'; $phpcsFile->addError($error, $stackPtr, 'Found'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/CSS/ForbiddenStylesSniff.php0000644000076500000240000001237713614652362026633 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\CSS; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class ForbiddenStylesSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['CSS']; /** * A list of forbidden styles with their alternatives. * * The value is NULL if no alternative exists. i.e., the * style should just not be used. * * @var array */ protected $forbiddenStyles = [ '-moz-border-radius' => 'border-radius', '-webkit-border-radius' => 'border-radius', '-moz-border-radius-topleft' => 'border-top-left-radius', '-moz-border-radius-topright' => 'border-top-right-radius', '-moz-border-radius-bottomright' => 'border-bottom-right-radius', '-moz-border-radius-bottomleft' => 'border-bottom-left-radius', '-moz-box-shadow' => 'box-shadow', '-webkit-box-shadow' => 'box-shadow', ]; /** * A cache of forbidden style names, for faster lookups. * * @var string[] */ protected $forbiddenStyleNames = []; /** * If true, forbidden styles will be considered regular expressions. * * @var boolean */ protected $patternMatch = false; /** * If true, an error will be thrown; otherwise a warning. * * @var boolean */ public $error = true; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { $this->forbiddenStyleNames = array_keys($this->forbiddenStyles); if ($this->patternMatch === true) { foreach ($this->forbiddenStyleNames as $i => $name) { $this->forbiddenStyleNames[$i] = '/'.$name.'/i'; } } return [T_STYLE]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $style = strtolower($tokens[$stackPtr]['content']); $pattern = null; if ($this->patternMatch === true) { $count = 0; $pattern = preg_replace( $this->forbiddenStyleNames, $this->forbiddenStyleNames, $style, 1, $count ); if ($count === 0) { return; } // Remove the pattern delimiters and modifier. $pattern = substr($pattern, 1, -2); } else { if (in_array($style, $this->forbiddenStyleNames, true) === false) { return; } }//end if $this->addError($phpcsFile, $stackPtr, $style, $pattern); }//end process() /** * Generates the error or warning for this sniff. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the forbidden style * in the token array. * @param string $style The name of the forbidden style. * @param string $pattern The pattern used for the match. * * @return void */ protected function addError($phpcsFile, $stackPtr, $style, $pattern=null) { $data = [$style]; $error = 'The use of style %s is '; if ($this->error === true) { $type = 'Found'; $error .= 'forbidden'; } else { $type = 'Discouraged'; $error .= 'discouraged'; } if ($pattern === null) { $pattern = $style; } if ($this->forbiddenStyles[$pattern] !== null) { $data[] = $this->forbiddenStyles[$pattern]; if ($this->error === true) { $fix = $phpcsFile->addFixableError($error.'; use %s instead', $stackPtr, $type.'WithAlternative', $data); } else { $fix = $phpcsFile->addFixableWarning($error.'; use %s instead', $stackPtr, $type.'WithAlternative', $data); } if ($fix === true) { $phpcsFile->fixer->replaceToken($stackPtr, $this->forbiddenStyles[$pattern]); } } else { if ($this->error === true) { $phpcsFile->addError($error, $stackPtr, $type, $data); } else { $phpcsFile->addWarning($error, $stackPtr, $type, $data); } } }//end addError() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/CSS/IndentationSniff.php0000644000076500000240000001133213614652362025775 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\CSS; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class IndentationSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['CSS']; /** * The number of spaces code should be indented. * * @var integer */ public $indent = 4; /** * Returns the token types that this sniff is interested in. * * @return int[] */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes the tokens that this sniff is interested in. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $numTokens = (count($tokens) - 2); $indentLevel = 0; $nestingLevel = 0; for ($i = 1; $i < $numTokens; $i++) { if ($tokens[$i]['code'] === T_COMMENT || isset(Tokens::$phpcsCommentTokens[$tokens[$i]['code']]) === true ) { // Don't check the indent of comments. continue; } if ($tokens[$i]['code'] === T_OPEN_CURLY_BRACKET) { $indentLevel++; if (isset($tokens[$i]['bracket_closer']) === false) { // Syntax error or live coding. // Anything after this would receive incorrect fixes, so bow out. return; } // Check for nested class definitions. $found = $phpcsFile->findNext( T_OPEN_CURLY_BRACKET, ($i + 1), $tokens[$i]['bracket_closer'] ); if ($found !== false) { $nestingLevel = $indentLevel; } } if (($tokens[$i]['code'] === T_CLOSE_CURLY_BRACKET && $tokens[$i]['line'] !== $tokens[($i - 1)]['line']) || ($tokens[($i + 1)]['code'] === T_CLOSE_CURLY_BRACKET && $tokens[$i]['line'] === $tokens[($i + 1)]['line']) ) { $indentLevel--; if ($indentLevel === 0) { $nestingLevel = 0; } } if ($tokens[$i]['column'] !== 1 || $tokens[$i]['code'] === T_OPEN_CURLY_BRACKET || $tokens[$i]['code'] === T_CLOSE_CURLY_BRACKET ) { continue; } // We started a new line, so check indent. if ($tokens[$i]['code'] === T_WHITESPACE) { $content = str_replace($phpcsFile->eolChar, '', $tokens[$i]['content']); $foundIndent = strlen($content); } else { $foundIndent = 0; } $expectedIndent = ($indentLevel * $this->indent); if ($expectedIndent > 0 && strpos($tokens[$i]['content'], $phpcsFile->eolChar) !== false ) { if ($nestingLevel !== $indentLevel) { $error = 'Blank lines are not allowed in class definitions'; $fix = $phpcsFile->addFixableError($error, $i, 'BlankLine'); if ($fix === true) { $phpcsFile->fixer->replaceToken($i, ''); } } } else if ($foundIndent !== $expectedIndent) { $error = 'Line indented incorrectly; expected %s spaces, found %s'; $data = [ $expectedIndent, $foundIndent, ]; $fix = $phpcsFile->addFixableError($error, $i, 'Incorrect', $data); if ($fix === true) { $indent = str_repeat(' ', $expectedIndent); if ($foundIndent === 0) { $phpcsFile->fixer->addContentBefore($i, $indent); } else { $phpcsFile->fixer->replaceToken($i, $indent); } } }//end if }//end for }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/CSS/LowercaseStyleDefinitionSniff.php0000644000076500000240000000543013614652362030501 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\CSS; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class LowercaseStyleDefinitionSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['CSS']; /** * Returns the token types that this sniff is interested in. * * @return int[] */ public function register() { return [T_OPEN_CURLY_BRACKET]; }//end register() /** * Processes the tokens that this sniff is interested in. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $start = ($stackPtr + 1); $end = ($tokens[$stackPtr]['bracket_closer'] - 1); $inStyle = null; for ($i = $start; $i <= $end; $i++) { // Skip nested definitions as they are checked individually. if ($tokens[$i]['code'] === T_OPEN_CURLY_BRACKET) { $i = $tokens[$i]['bracket_closer']; continue; } if ($tokens[$i]['code'] === T_STYLE) { $inStyle = $tokens[$i]['content']; } if ($tokens[$i]['code'] === T_SEMICOLON) { $inStyle = null; } if ($inStyle === 'progid') { // Special case for IE filters. continue; } if ($tokens[$i]['code'] === T_STYLE || ($inStyle !== null && $tokens[$i]['code'] === T_STRING) ) { $expected = strtolower($tokens[$i]['content']); if ($expected !== $tokens[$i]['content']) { $error = 'Style definitions must be lowercase; expected %s but found %s'; $data = [ $expected, $tokens[$i]['content'], ]; $fix = $phpcsFile->addFixableError($error, $i, 'FoundUpper', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken($i, $expected); } } } }//end for }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/CSS/MissingColonSniff.php0000644000076500000240000000515313614652362026131 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\CSS; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class MissingColonSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['CSS']; /** * Returns the token types that this sniff is interested in. * * @return int[] */ public function register() { return [T_OPEN_CURLY_BRACKET]; }//end register() /** * Processes the tokens that this sniff is interested in. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['bracket_closer']) === false) { // Syntax error or live coding, bow out. return; } $lastLine = $tokens[$stackPtr]['line']; $end = $tokens[$stackPtr]['bracket_closer']; // Do not check nested style definitions as, for example, in @media style rules. $nested = $phpcsFile->findNext(T_OPEN_CURLY_BRACKET, ($stackPtr + 1), $end); if ($nested !== false) { return; } $foundColon = false; $foundString = false; for ($i = ($stackPtr + 1); $i <= $end; $i++) { if ($tokens[$i]['line'] !== $lastLine) { // We changed lines. if ($foundColon === false && $foundString !== false) { // We didn't find a colon on the previous line. $error = 'No style definition found on line; check for missing colon'; $phpcsFile->addError($error, $foundString, 'Found'); } $foundColon = false; $foundString = false; $lastLine = $tokens[$i]['line']; } if ($tokens[$i]['code'] === T_STRING) { $foundString = $i; } else if ($tokens[$i]['code'] === T_COLON) { $foundColon = $i; } }//end for }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/CSS/NamedColoursSniff.php0000644000076500000240000000456413614652362026125 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\CSS; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class NamedColoursSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['CSS']; /** * A list of named colours. * * This is the list of standard colours defined in the CSS specification. * * @var array */ protected $colourNames = [ 'aqua' => 'aqua', 'black' => 'black', 'blue' => 'blue', 'fuchsia' => 'fuchsia', 'gray' => 'gray', 'green' => 'green', 'lime' => 'lime', 'maroon' => 'maroon', 'navy' => 'navy', 'olive' => 'olive', 'orange' => 'orange', 'purple' => 'purple', 'red' => 'red', 'silver' => 'silver', 'teal' => 'teal', 'white' => 'white', 'yellow' => 'yellow', ]; /** * Returns the token types that this sniff is interested in. * * @return int[] */ public function register() { return [T_STRING]; }//end register() /** * Processes the tokens that this sniff is interested in. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if ($tokens[($stackPtr - 1)]['code'] === T_HASH || $tokens[($stackPtr - 1)]['code'] === T_STRING_CONCAT ) { // Class name. return; } if (isset($this->colourNames[strtolower($tokens[$stackPtr]['content'])]) === true) { $error = 'Named colours are forbidden; use hex, rgb, or rgba values instead'; $phpcsFile->addError($error, $stackPtr, 'Forbidden'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/CSS/OpacitySniff.php0000644000076500000240000000631513614652362025136 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\CSS; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class OpacitySniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['CSS']; /** * Returns the token types that this sniff is interested in. * * @return int[] */ public function register() { return [T_STYLE]; }//end register() /** * Processes the tokens that this sniff is interested in. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if ($tokens[$stackPtr]['content'] !== 'opacity') { return; } $ignore = Tokens::$emptyTokens; $ignore[] = T_COLON; $next = $phpcsFile->findNext($ignore, ($stackPtr + 1), null, true); if ($next === false || ($tokens[$next]['code'] !== T_DNUMBER && $tokens[$next]['code'] !== T_LNUMBER) ) { return; } $value = $tokens[$next]['content']; if ($tokens[$next]['code'] === T_LNUMBER) { if ($value !== '0' && $value !== '1') { $error = 'Opacity values must be between 0 and 1'; $phpcsFile->addError($error, $next, 'Invalid'); } } else { if (strlen($value) > 3) { $error = 'Opacity values must have a single value after the decimal point'; $phpcsFile->addError($error, $next, 'DecimalPrecision'); } else if ($value === '0.0' || $value === '1.0') { $error = 'Opacity value does not require decimal point; use %s instead'; $data = [$value[0]]; $fix = $phpcsFile->addFixableError($error, $next, 'PointNotRequired', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken($next, $value[0]); } } else if ($value[0] === '.') { $error = 'Opacity values must not start with a decimal point; use 0%s instead'; $data = [$value]; $fix = $phpcsFile->addFixableError($error, $next, 'StartWithPoint', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken($next, '0'.$value); } } else if ($value[0] !== '0') { $error = 'Opacity values must be between 0 and 1'; $phpcsFile->addError($error, $next, 'Invalid'); }//end if }//end if }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/CSS/SemicolonSpacingSniff.php0000644000076500000240000000627213614652362026765 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\CSS; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class SemicolonSpacingSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['CSS']; /** * Returns the token types that this sniff is interested in. * * @return int[] */ public function register() { return [T_STYLE]; }//end register() /** * Processes the tokens that this sniff is interested in. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $nextStatement = $phpcsFile->findNext([T_STYLE, T_CLOSE_CURLY_BRACKET], ($stackPtr + 1)); if ($nextStatement === false) { return; } $ignore = Tokens::$emptyTokens; if ($tokens[$nextStatement]['code'] === T_STYLE) { // Allow for star-prefix hack. $ignore[] = T_MULTIPLY; } $endOfThisStatement = $phpcsFile->findPrevious($ignore, ($nextStatement - 1), null, true); if ($tokens[$endOfThisStatement]['code'] !== T_SEMICOLON) { $error = 'Style definitions must end with a semicolon'; $phpcsFile->addError($error, $endOfThisStatement, 'NotAtEnd'); return; } if ($tokens[($endOfThisStatement - 1)]['code'] !== T_WHITESPACE) { return; } // There is a semi-colon, so now find the last token in the statement. $prevNonEmpty = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($endOfThisStatement - 1), null, true); $found = $tokens[($endOfThisStatement - 1)]['length']; if ($tokens[$prevNonEmpty]['line'] !== $tokens[$endOfThisStatement]['line']) { $found = 'newline'; } $error = 'Expected 0 spaces before semicolon in style definition; %s found'; $data = [$found]; $fix = $phpcsFile->addFixableError($error, $prevNonEmpty, 'SpaceFound', $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->addContent($prevNonEmpty, ';'); $phpcsFile->fixer->replaceToken($endOfThisStatement, ''); for ($i = ($endOfThisStatement - 1); $i > $prevNonEmpty; $i--) { if ($tokens[$i]['code'] !== T_WHITESPACE) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/CSS/ShorthandSizeSniff.php0000644000076500000240000001277313614652362026320 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\CSS; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class ShorthandSizeSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['CSS']; /** * A list of styles that we shouldn't check. * * These have values that looks like sizes, but are not. * * @var array */ protected $excludeStyles = [ 'background-position' => 'background-position', 'box-shadow' => 'box-shadow', 'transform-origin' => 'transform-origin', '-webkit-transform-origin' => '-webkit-transform-origin', '-ms-transform-origin' => '-ms-transform-origin', ]; /** * Returns the token types that this sniff is interested in. * * @return int[] */ public function register() { return [T_STYLE]; }//end register() /** * Processes the tokens that this sniff is interested in. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Some styles look like shorthand but are not actually a set of 4 sizes. $style = strtolower($tokens[$stackPtr]['content']); if (isset($this->excludeStyles[$style]) === true) { return; } $end = $phpcsFile->findNext(T_SEMICOLON, ($stackPtr + 1)); if ($end === false) { // Live coding or parse error. return; } // Get the whole style content. $origContent = $phpcsFile->getTokensAsString(($stackPtr + 1), ($end - $stackPtr - 1)); $origContent = trim($origContent, ':'); $origContent = trim($origContent); // Account for a !important annotation. $content = $origContent; if (substr($content, -10) === '!important') { $content = substr($content, 0, -10); $content = trim($content); } // Check if this style value is a set of numbers with optional prefixes. $content = preg_replace('/\s+/', ' ', $content); $values = []; $num = preg_match_all( '/(?:[0-9]+)(?:[a-zA-Z]{2}\s+|%\s+|\s+)/', $content.' ', $values, PREG_SET_ORDER ); // Only interested in styles that have multiple sizes defined. if ($num < 2) { return; } // Rebuild the content we matched to ensure we got everything. $matched = ''; foreach ($values as $value) { $matched .= $value[0]; } if ($content !== trim($matched)) { return; } if ($num === 3) { $expected = trim($content.' '.$values[1][0]); $error = 'Shorthand syntax not allowed here; use %s instead'; $data = [$expected]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NotAllowed', $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); if (substr($origContent, -10) === '!important') { $expected .= ' !important'; } $next = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 2), null, true); $phpcsFile->fixer->replaceToken($next, $expected); for ($next++; $next < $end; $next++) { $phpcsFile->fixer->replaceToken($next, ''); } $phpcsFile->fixer->endChangeset(); } return; }//end if if ($num === 2) { if ($values[0][0] !== $values[1][0]) { // Both values are different, so it is already shorthand. return; } } else if ($values[0][0] !== $values[2][0] || $values[1][0] !== $values[3][0]) { // Can't shorthand this. return; } if ($values[0][0] === $values[1][0]) { // All values are the same. $expected = trim($values[0][0]); } else { $expected = trim($values[0][0]).' '.trim($values[1][0]); } $error = 'Size definitions must use shorthand if available; expected "%s" but found "%s"'; $data = [ $expected, $content, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NotUsed', $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); if (substr($origContent, -10) === '!important') { $expected .= ' !important'; } $next = $phpcsFile->findNext(T_COLON, ($stackPtr + 1)); $phpcsFile->fixer->addContent($next, ' '.$expected); for ($next++; $next < $end; $next++) { $phpcsFile->fixer->replaceToken($next, ''); } $phpcsFile->fixer->endChangeset(); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Debug/JavaScriptLintSniff.php0000644000076500000240000000520513614652362027016 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Debug; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Exceptions\RuntimeException; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class JavaScriptLintSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['JS']; /** * Returns the token types that this sniff is interested in. * * @return int[] */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes the tokens that this sniff is interested in. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If Javascript Lint ran into trouble. */ public function process(File $phpcsFile, $stackPtr) { $jslPath = Config::getExecutablePath('jsl'); if ($jslPath === null) { return; } $fileName = $phpcsFile->getFilename(); $cmd = '"'.escapeshellcmd($jslPath).'" -nologo -nofilelisting -nocontext -nosummary -output-format __LINE__:__ERROR__ -process '.escapeshellarg($fileName); $msg = exec($cmd, $output, $retval); // Variable $exitCode is the last line of $output if no error occurs, on // error it is numeric. Try to handle various error conditions and // provide useful error reporting. if ($retval === 2 || $retval === 4) { if (is_array($output) === true) { $msg = join('\n', $output); } throw new RuntimeException("Failed invoking JavaScript Lint, retval was [$retval], output was [$msg]"); } if (is_array($output) === true) { foreach ($output as $finding) { $split = strpos($finding, ':'); $line = substr($finding, 0, $split); $message = substr($finding, ($split + 1)); $phpcsFile->addWarningOnLine(trim($message), $line, 'ExternalTool'); } } // Ignore the rest of the file. return ($phpcsFile->numTokens + 1); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Debug/JSLintSniff.php0000644000076500000240000000453613614652362025272 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Debug; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class JSLintSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['JS']; /** * Returns the token types that this sniff is interested in. * * @return int[] */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes the tokens that this sniff is interested in. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If jslint.js could not be run */ public function process(File $phpcsFile, $stackPtr) { $rhinoPath = Config::getExecutablePath('jslint'); $jslintPath = Config::getExecutablePath('jslint'); if ($rhinoPath === null || $jslintPath === null) { return; } $fileName = $phpcsFile->getFilename(); $rhinoPath = escapeshellcmd($rhinoPath); $jslintPath = escapeshellcmd($jslintPath); $cmd = "$rhinoPath \"$jslintPath\" ".escapeshellarg($fileName); exec($cmd, $output, $retval); if (is_array($output) === true) { foreach ($output as $finding) { $matches = []; $numMatches = preg_match('/Lint at line ([0-9]+).*:(.*)$/', $finding, $matches); if ($numMatches === 0) { continue; } $line = (int) $matches[1]; $message = 'jslint says: '.trim($matches[2]); $phpcsFile->addWarningOnLine($message, $line, 'ExternalTool'); } } // Ignore the rest of the file. return ($phpcsFile->numTokens + 1); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Files/FileExtensionSniff.php0000644000076500000240000000425513614652362026715 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Files; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class FileExtensionSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return int */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $fileName = $phpcsFile->getFilename(); $extension = substr($fileName, strrpos($fileName, '.')); $nextClass = $phpcsFile->findNext([T_CLASS, T_INTERFACE, T_TRAIT], $stackPtr); if ($nextClass !== false) { $phpcsFile->recordMetric($stackPtr, 'File extension for class files', $extension); if ($extension === '.php') { $error = '%s found in ".php" file; use ".inc" extension instead'; $data = [ucfirst($tokens[$nextClass]['content'])]; $phpcsFile->addError($error, $stackPtr, 'ClassFound', $data); } } else { $phpcsFile->recordMetric($stackPtr, 'File extension for non-class files', $extension); if ($extension === '.inc') { $error = 'No interface or class found in ".inc" file; use ".php" extension instead'; $phpcsFile->addError($error, $stackPtr, 'NoClass'); } } // Ignore the rest of the file. return ($phpcsFile->numTokens + 1); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Formatting/OperatorBracketSniff.php0000644000076500000240000003554113614652362030302 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Formatting; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class OperatorBracketSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return Tokens::$operators; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if ($phpcsFile->tokenizerType === 'JS' && $tokens[$stackPtr]['code'] === T_PLUS) { // JavaScript uses the plus operator for string concatenation as well // so we cannot accurately determine if it is a string concat or addition. // So just ignore it. return; } // If the & is a reference, then we don't want to check for brackets. if ($tokens[$stackPtr]['code'] === T_BITWISE_AND && $phpcsFile->isReference($stackPtr) === true) { return; } // There is one instance where brackets aren't needed, which involves // the minus sign being used to assign a negative number to a variable. if ($tokens[$stackPtr]['code'] === T_MINUS) { // Check to see if we are trying to return -n. $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); if ($tokens[$prev]['code'] === T_RETURN) { return; } $number = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($tokens[$number]['code'] === T_LNUMBER || $tokens[$number]['code'] === T_DNUMBER) { $previous = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true); if ($previous !== false) { $isAssignment = isset(Tokens::$assignmentTokens[$tokens[$previous]['code']]); $isEquality = isset(Tokens::$equalityTokens[$tokens[$previous]['code']]); $isComparison = isset(Tokens::$comparisonTokens[$tokens[$previous]['code']]); if ($isAssignment === true || $isEquality === true || $isComparison === true) { // This is a negative assignment or comparison. // We need to check that the minus and the number are // adjacent. if (($number - $stackPtr) !== 1) { $error = 'No space allowed between minus sign and number'; $phpcsFile->addError($error, $stackPtr, 'SpacingAfterMinus'); } return; } } } }//end if $previousToken = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true, null, true); if ($previousToken !== false) { // A list of tokens that indicate that the token is not // part of an arithmetic operation. $invalidTokens = [ T_COMMA => true, T_COLON => true, T_OPEN_PARENTHESIS => true, T_OPEN_SQUARE_BRACKET => true, T_OPEN_CURLY_BRACKET => true, T_OPEN_SHORT_ARRAY => true, T_CASE => true, ]; if (isset($invalidTokens[$tokens[$previousToken]['code']]) === true) { return; } } if ($tokens[$stackPtr]['code'] === T_BITWISE_OR && isset($tokens[$stackPtr]['nested_parenthesis']) === true ) { $brackets = $tokens[$stackPtr]['nested_parenthesis']; $lastBracket = array_pop($brackets); if (isset($tokens[$lastBracket]['parenthesis_owner']) === true && $tokens[$tokens[$lastBracket]['parenthesis_owner']]['code'] === T_CATCH ) { // This is a pipe character inside a catch statement, so it is acting // as an exception type separator and not an arithmetic operation. return; } } // Tokens that are allowed inside a bracketed operation. $allowed = [ T_VARIABLE, T_LNUMBER, T_DNUMBER, T_STRING, T_WHITESPACE, T_NS_SEPARATOR, T_THIS, T_SELF, T_STATIC, T_OBJECT_OPERATOR, T_DOUBLE_COLON, T_OPEN_SQUARE_BRACKET, T_CLOSE_SQUARE_BRACKET, T_MODULUS, T_NONE, T_BITWISE_NOT, ]; $allowed += Tokens::$operators; $lastBracket = false; if (isset($tokens[$stackPtr]['nested_parenthesis']) === true) { $parenthesis = array_reverse($tokens[$stackPtr]['nested_parenthesis'], true); foreach ($parenthesis as $bracket => $endBracket) { $prevToken = $phpcsFile->findPrevious(T_WHITESPACE, ($bracket - 1), null, true); $prevCode = $tokens[$prevToken]['code']; if ($prevCode === T_ISSET) { // This operation is inside an isset() call, but has // no bracket of it's own. break; } if ($prevCode === T_STRING || $prevCode === T_SWITCH) { // We allow simple operations to not be bracketed. // For example, ceil($one / $two). for ($prev = ($stackPtr - 1); $prev > $bracket; $prev--) { if (in_array($tokens[$prev]['code'], $allowed, true) === true) { continue; } if ($tokens[$prev]['code'] === T_CLOSE_PARENTHESIS) { $prev = $tokens[$prev]['parenthesis_opener']; } else { break; } } if ($prev !== $bracket) { break; } for ($next = ($stackPtr + 1); $next < $endBracket; $next++) { if (in_array($tokens[$next]['code'], $allowed, true) === true) { continue; } if ($tokens[$next]['code'] === T_OPEN_PARENTHESIS) { $next = $tokens[$next]['parenthesis_closer']; } else { break; } } if ($next !== $endBracket) { break; } }//end if if (in_array($prevCode, Tokens::$scopeOpeners, true) === true) { // This operation is inside a control structure like FOREACH // or IF, but has no bracket of it's own. // The only control structure allowed to do this is SWITCH. if ($prevCode !== T_SWITCH) { break; } } if ($prevCode === T_OPEN_PARENTHESIS) { // These are two open parenthesis in a row. If the current // one doesn't enclose the operator, go to the previous one. if ($endBracket < $stackPtr) { continue; } } $lastBracket = $bracket; break; }//end foreach }//end if if ($lastBracket === false) { // It is not in a bracketed statement at all. $this->addMissingBracketsError($phpcsFile, $stackPtr); return; } else if ($tokens[$lastBracket]['parenthesis_closer'] < $stackPtr) { // There are a set of brackets in front of it that don't include it. $this->addMissingBracketsError($phpcsFile, $stackPtr); return; } else { // We are enclosed in a set of bracket, so the last thing to // check is that we are not also enclosed in square brackets // like this: ($array[$index + 1]), which is invalid. $brackets = [ T_OPEN_SQUARE_BRACKET, T_CLOSE_SQUARE_BRACKET, ]; $squareBracket = $phpcsFile->findPrevious($brackets, ($stackPtr - 1), $lastBracket); if ($squareBracket !== false && $tokens[$squareBracket]['code'] === T_OPEN_SQUARE_BRACKET) { $closeSquareBracket = $phpcsFile->findNext($brackets, ($stackPtr + 1)); if ($closeSquareBracket !== false && $tokens[$closeSquareBracket]['code'] === T_CLOSE_SQUARE_BRACKET) { $this->addMissingBracketsError($phpcsFile, $stackPtr); } } return; }//end if $lastAssignment = $phpcsFile->findPrevious(Tokens::$assignmentTokens, $stackPtr, null, false, null, true); if ($lastAssignment !== false && $lastAssignment > $lastBracket) { $this->addMissingBracketsError($phpcsFile, $stackPtr); } }//end process() /** * Add and fix the missing brackets error. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function addMissingBracketsError($phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $allowed = [ T_VARIABLE => true, T_LNUMBER => true, T_DNUMBER => true, T_STRING => true, T_CONSTANT_ENCAPSED_STRING => true, T_DOUBLE_QUOTED_STRING => true, T_WHITESPACE => true, T_NS_SEPARATOR => true, T_THIS => true, T_SELF => true, T_STATIC => true, T_OBJECT_OPERATOR => true, T_DOUBLE_COLON => true, T_MODULUS => true, T_ISSET => true, T_ARRAY => true, T_NONE => true, T_BITWISE_NOT => true, ]; // Find the first token in the expression. for ($before = ($stackPtr - 1); $before > 0; $before--) { // Special case for plus operators because we can't tell if they are used // for addition or string contact. So assume string concat to be safe. if ($phpcsFile->tokenizerType === 'JS' && $tokens[$before]['code'] === T_PLUS) { break; } if (isset(Tokens::$emptyTokens[$tokens[$before]['code']]) === true || isset(Tokens::$operators[$tokens[$before]['code']]) === true || isset(Tokens::$castTokens[$tokens[$before]['code']]) === true || isset($allowed[$tokens[$before]['code']]) === true ) { continue; } if ($tokens[$before]['code'] === T_CLOSE_PARENTHESIS) { $before = $tokens[$before]['parenthesis_opener']; continue; } if ($tokens[$before]['code'] === T_CLOSE_SQUARE_BRACKET) { $before = $tokens[$before]['bracket_opener']; continue; } if ($tokens[$before]['code'] === T_CLOSE_SHORT_ARRAY) { $before = $tokens[$before]['bracket_opener']; continue; } break; }//end for $before = $phpcsFile->findNext(Tokens::$emptyTokens, ($before + 1), null, true); // Find the last token in the expression. for ($after = ($stackPtr + 1); $after < $phpcsFile->numTokens; $after++) { // Special case for plus operators because we can't tell if they are used // for addition or string concat. So assume string concat to be safe. if ($phpcsFile->tokenizerType === 'JS' && $tokens[$after]['code'] === T_PLUS) { break; } if (isset(Tokens::$emptyTokens[$tokens[$after]['code']]) === true || isset(Tokens::$operators[$tokens[$after]['code']]) === true || isset(Tokens::$castTokens[$tokens[$after]['code']]) === true || isset($allowed[$tokens[$after]['code']]) === true ) { continue; } if ($tokens[$after]['code'] === T_OPEN_PARENTHESIS) { $after = $tokens[$after]['parenthesis_closer']; continue; } if ($tokens[$after]['code'] === T_OPEN_SQUARE_BRACKET) { $after = $tokens[$after]['bracket_closer']; continue; } if ($tokens[$after]['code'] === T_OPEN_SHORT_ARRAY) { $after = $tokens[$after]['bracket_closer']; continue; } break; }//end for $after = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($after - 1), null, true); $error = 'Operation must be bracketed'; if ($before === $after || $before === $stackPtr || $after === $stackPtr) { $phpcsFile->addError($error, $stackPtr, 'MissingBrackets'); return; } $fix = $phpcsFile->addFixableError($error, $stackPtr, 'MissingBrackets'); if ($fix === true) { // Can only fix this error if both tokens are available for fixing. // Adding one bracket without the other will create parse errors. $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->replaceToken($before, '('.$tokens[$before]['content']); $phpcsFile->fixer->replaceToken($after, $tokens[$after]['content'].')'); $phpcsFile->fixer->endChangeset(); } }//end addMissingBracketsError() }//end class ././@LongLink0000000000000000000000000000014600000000000007756 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Functions/FunctionDeclarationArgumentSpacingSniff.phpPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Functions/FunctionDeclarationArgumentSpacingSniff.p0000644000076500000240000003726413614652362033470 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Functions; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class FunctionDeclarationArgumentSpacingSniff implements Sniff { /** * How many spaces should surround the equals signs. * * @var integer */ public $equalsSpacing = 0; /** * How many spaces should follow the opening bracket. * * @var integer */ public $requiredSpacesAfterOpen = 0; /** * How many spaces should precede the closing bracket. * * @var integer */ public $requiredSpacesBeforeClose = 0; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_FUNCTION, T_CLOSURE, T_FN, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['parenthesis_opener']) === false || isset($tokens[$stackPtr]['parenthesis_closer']) === false || $tokens[$stackPtr]['parenthesis_opener'] === null || $tokens[$stackPtr]['parenthesis_closer'] === null ) { return; } $this->equalsSpacing = (int) $this->equalsSpacing; $this->requiredSpacesAfterOpen = (int) $this->requiredSpacesAfterOpen; $this->requiredSpacesBeforeClose = (int) $this->requiredSpacesBeforeClose; $this->processBracket($phpcsFile, $tokens[$stackPtr]['parenthesis_opener']); if ($tokens[$stackPtr]['code'] === T_CLOSURE) { $use = $phpcsFile->findNext(T_USE, ($tokens[$stackPtr]['parenthesis_closer'] + 1), $tokens[$stackPtr]['scope_opener']); if ($use !== false) { $openBracket = $phpcsFile->findNext(T_OPEN_PARENTHESIS, ($use + 1), null); $this->processBracket($phpcsFile, $openBracket); } } }//end process() /** * Processes the contents of a single set of brackets. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $openBracket The position of the open bracket * in the stack. * * @return void */ public function processBracket($phpcsFile, $openBracket) { $tokens = $phpcsFile->getTokens(); $closeBracket = $tokens[$openBracket]['parenthesis_closer']; $multiLine = ($tokens[$openBracket]['line'] !== $tokens[$closeBracket]['line']); if (isset($tokens[$openBracket]['parenthesis_owner']) === true) { $stackPtr = $tokens[$openBracket]['parenthesis_owner']; } else { $stackPtr = $phpcsFile->findPrevious(T_USE, ($openBracket - 1)); } $params = $phpcsFile->getMethodParameters($stackPtr); if (empty($params) === true) { // Check spacing around parenthesis. $next = $phpcsFile->findNext(T_WHITESPACE, ($openBracket + 1), $closeBracket, true); if ($next === false) { if (($closeBracket - $openBracket) !== 1) { $error = 'Expected 0 spaces between parenthesis of function declaration; %s found'; $data = [$tokens[($openBracket + 1)]['length']]; $fix = $phpcsFile->addFixableError($error, $openBracket, 'SpacingBetween', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($openBracket + 1), ''); } } // No params, so we don't check normal spacing rules. return; } } foreach ($params as $paramNumber => $param) { if ($param['pass_by_reference'] === true) { $refToken = $param['reference_token']; $gap = 0; if ($tokens[($refToken + 1)]['code'] === T_WHITESPACE) { $gap = $tokens[($refToken + 1)]['length']; } if ($gap !== 0) { $error = 'Expected 0 spaces after reference operator for argument "%s"; %s found'; $data = [ $param['name'], $gap, ]; $fix = $phpcsFile->addFixableError($error, $refToken, 'SpacingAfterReference', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($refToken + 1), ''); } } }//end if if ($param['variable_length'] === true) { $variadicToken = $param['variadic_token']; $gap = 0; if ($tokens[($variadicToken + 1)]['code'] === T_WHITESPACE) { $gap = $tokens[($variadicToken + 1)]['length']; } if ($gap !== 0) { $error = 'Expected 0 spaces after variadic operator for argument "%s"; %s found'; $data = [ $param['name'], $gap, ]; $fix = $phpcsFile->addFixableError($error, $variadicToken, 'SpacingAfterVariadic', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($variadicToken + 1), ''); } } }//end if if (isset($param['default_equal_token']) === true) { $equalToken = $param['default_equal_token']; $spacesBefore = 0; if (($equalToken - $param['token']) > 1) { $spacesBefore = $tokens[($param['token'] + 1)]['length']; } if ($spacesBefore !== $this->equalsSpacing) { $error = 'Incorrect spacing between argument "%s" and equals sign; expected '.$this->equalsSpacing.' but found %s'; $data = [ $param['name'], $spacesBefore, ]; $fix = $phpcsFile->addFixableError($error, $equalToken, 'SpaceBeforeEquals', $data); if ($fix === true) { $padding = str_repeat(' ', $this->equalsSpacing); if ($spacesBefore === 0) { $phpcsFile->fixer->addContentBefore($equalToken, $padding); } else { $phpcsFile->fixer->replaceToken(($equalToken - 1), $padding); } } }//end if $spacesAfter = 0; if ($tokens[($equalToken + 1)]['code'] === T_WHITESPACE) { $spacesAfter = $tokens[($equalToken + 1)]['length']; } if ($spacesAfter !== $this->equalsSpacing) { $error = 'Incorrect spacing between default value and equals sign for argument "%s"; expected '.$this->equalsSpacing.' but found %s'; $data = [ $param['name'], $spacesAfter, ]; $fix = $phpcsFile->addFixableError($error, $equalToken, 'SpaceAfterEquals', $data); if ($fix === true) { $padding = str_repeat(' ', $this->equalsSpacing); if ($spacesAfter === 0) { $phpcsFile->fixer->addContent($equalToken, $padding); } else { $phpcsFile->fixer->replaceToken(($equalToken + 1), $padding); } } }//end if }//end if if ($param['type_hint_token'] !== false) { $typeHintToken = $param['type_hint_end_token']; $gap = 0; if ($tokens[($typeHintToken + 1)]['code'] === T_WHITESPACE) { $gap = $tokens[($typeHintToken + 1)]['length']; } if ($gap !== 1) { $error = 'Expected 1 space between type hint and argument "%s"; %s found'; $data = [ $param['name'], $gap, ]; $fix = $phpcsFile->addFixableError($error, $typeHintToken, 'SpacingAfterHint', $data); if ($fix === true) { if ($gap === 0) { $phpcsFile->fixer->addContent($typeHintToken, ' '); } else { $phpcsFile->fixer->replaceToken(($typeHintToken + 1), ' '); } } } }//end if $commaToken = false; if ($paramNumber > 0 && $params[($paramNumber - 1)]['comma_token'] !== false) { $commaToken = $params[($paramNumber - 1)]['comma_token']; } if ($commaToken !== false) { if ($tokens[($commaToken - 1)]['code'] === T_WHITESPACE) { $error = 'Expected 0 spaces between argument "%s" and comma; %s found'; $data = [ $params[($paramNumber - 1)]['name'], $tokens[($commaToken - 1)]['length'], ]; $fix = $phpcsFile->addFixableError($error, $commaToken, 'SpaceBeforeComma', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($commaToken - 1), ''); } } // Don't check spacing after the comma if it is the last content on the line. $checkComma = true; if ($multiLine === true) { $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($commaToken + 1), $closeBracket, true); if ($tokens[$next]['line'] !== $tokens[$commaToken]['line']) { $checkComma = false; } } if ($checkComma === true) { if ($param['type_hint_token'] === false) { $spacesAfter = 0; if ($tokens[($commaToken + 1)]['code'] === T_WHITESPACE) { $spacesAfter = $tokens[($commaToken + 1)]['length']; } if ($spacesAfter === 0) { $error = 'Expected 1 space between comma and argument "%s"; 0 found'; $data = [$param['name']]; $fix = $phpcsFile->addFixableError($error, $commaToken, 'NoSpaceBeforeArg', $data); if ($fix === true) { $phpcsFile->fixer->addContent($commaToken, ' '); } } else if ($spacesAfter !== 1) { $error = 'Expected 1 space between comma and argument "%s"; %s found'; $data = [ $param['name'], $spacesAfter, ]; $fix = $phpcsFile->addFixableError($error, $commaToken, 'SpacingBeforeArg', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($commaToken + 1), ' '); } }//end if } else { $hint = $phpcsFile->getTokensAsString($param['type_hint_token'], (($param['type_hint_end_token'] - $param['type_hint_token']) + 1)); if ($param['nullable_type'] === true) { $hint = '?'.$hint; } if ($tokens[($commaToken + 1)]['code'] !== T_WHITESPACE) { $error = 'Expected 1 space between comma and type hint "%s"; 0 found'; $data = [$hint]; $fix = $phpcsFile->addFixableError($error, $commaToken, 'NoSpaceBeforeHint', $data); if ($fix === true) { $phpcsFile->fixer->addContent($commaToken, ' '); } } else { $gap = $tokens[($commaToken + 1)]['length']; if ($gap !== 1) { $error = 'Expected 1 space between comma and type hint "%s"; %s found'; $data = [ $hint, $gap, ]; $fix = $phpcsFile->addFixableError($error, $commaToken, 'SpacingBeforeHint', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($commaToken + 1), ' '); } } }//end if }//end if }//end if }//end if }//end foreach // Only check spacing around parenthesis for single line definitions. if ($multiLine === true) { return; } $gap = 0; if ($tokens[($closeBracket - 1)]['code'] === T_WHITESPACE) { $gap = $tokens[($closeBracket - 1)]['length']; } if ($gap !== $this->requiredSpacesBeforeClose) { $error = 'Expected %s spaces before closing parenthesis; %s found'; $data = [ $this->requiredSpacesBeforeClose, $gap, ]; $fix = $phpcsFile->addFixableError($error, $closeBracket, 'SpacingBeforeClose', $data); if ($fix === true) { $padding = str_repeat(' ', $this->requiredSpacesBeforeClose); if ($gap === 0) { $phpcsFile->fixer->addContentBefore($closeBracket, $padding); } else { $phpcsFile->fixer->replaceToken(($closeBracket - 1), $padding); } } } $gap = 0; if ($tokens[($openBracket + 1)]['code'] === T_WHITESPACE) { $gap = $tokens[($openBracket + 1)]['length']; } if ($gap !== $this->requiredSpacesAfterOpen) { $error = 'Expected %s spaces after opening parenthesis; %s found'; $data = [ $this->requiredSpacesAfterOpen, $gap, ]; $fix = $phpcsFile->addFixableError($error, $openBracket, 'SpacingAfterOpen', $data); if ($fix === true) { $padding = str_repeat(' ', $this->requiredSpacesAfterOpen); if ($gap === 0) { $phpcsFile->fixer->addContent($openBracket, $padding); } else { $phpcsFile->fixer->replaceToken(($openBracket + 1), $padding); } } } }//end processBracket() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Functions/FunctionDeclarationSniff.php0000644000076500000240000000140013614652362030767 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Functions; use PHP_CodeSniffer\Sniffs\AbstractPatternSniff; class FunctionDeclarationSniff extends AbstractPatternSniff { /** * Returns an array of patterns to check are correct. * * @return array */ protected function getPatterns() { return [ 'function abc(...);', 'function abc(...)', 'abstract function abc(...);', ]; }//end getPatterns() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Functions/FunctionDuplicateArgumentSniff.php0000644000076500000240000000360413614652362032167 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Functions; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class FunctionDuplicateArgumentSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_FUNCTION]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $openBracket = $tokens[$stackPtr]['parenthesis_opener']; $closeBracket = $tokens[$stackPtr]['parenthesis_closer']; $foundVariables = []; for ($i = ($openBracket + 1); $i < $closeBracket; $i++) { if ($tokens[$i]['code'] === T_VARIABLE) { $variable = $tokens[$i]['content']; if (in_array($variable, $foundVariables, true) === true) { $error = 'Variable "%s" appears more than once in function declaration'; $data = [$variable]; $phpcsFile->addError($error, $i, 'Found', $data); } else { $foundVariables[] = $variable; } } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Functions/GlobalFunctionSniff.php0000644000076500000240000000326213614652362027752 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Functions; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class GlobalFunctionSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_FUNCTION]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (empty($tokens[$stackPtr]['conditions']) === true) { $functionName = $phpcsFile->getDeclarationName($stackPtr); if ($functionName === null) { return; } // Special exception for __autoload as it needs to be global. if ($functionName !== '__autoload') { $error = 'Consider putting global function "%s" in a static class'; $data = [$functionName]; $phpcsFile->addWarning($error, $stackPtr, 'Found', $data); } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Functions/LowercaseFunctionKeywordsSniff.php0000644000076500000240000000355113614652362032227 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Functions; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class LowercaseFunctionKeywordsSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { $tokens = Tokens::$methodPrefixes; $tokens[] = T_FUNCTION; $tokens[] = T_CLOSURE; $tokens[] = T_FN; return $tokens; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $content = $tokens[$stackPtr]['content']; $contentLc = strtolower($content); if ($content !== $contentLc) { $error = '%s keyword must be lowercase; expected "%s" but found "%s"'; $data = [ strtoupper($content), $contentLc, $content, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'FoundUppercase', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken($stackPtr, $contentLc); } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Functions/MultiLineFunctionDeclarationSniff.php0000644000076500000240000002501313614652362032620 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Functions; use PHP_CodeSniffer\Standards\PEAR\Sniffs\Functions\FunctionDeclarationSniff as PEARFunctionDeclarationSniff; use PHP_CodeSniffer\Util\Tokens; class MultiLineFunctionDeclarationSniff extends PEARFunctionDeclarationSniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * Determine if this is a multi-line function declaration. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param int $openBracket The position of the opening bracket * in the stack passed in $tokens. * @param array $tokens The stack of tokens that make up * the file. * * @return void */ public function isMultiLineDeclaration($phpcsFile, $stackPtr, $openBracket, $tokens) { $bracketsToCheck = [$stackPtr => $openBracket]; // Closures may use the USE keyword and so be multi-line in this way. if ($tokens[$stackPtr]['code'] === T_CLOSURE) { $use = $phpcsFile->findNext(T_USE, ($tokens[$openBracket]['parenthesis_closer'] + 1), $tokens[$stackPtr]['scope_opener']); if ($use !== false) { $open = $phpcsFile->findNext(T_OPEN_PARENTHESIS, ($use + 1)); if ($open !== false) { $bracketsToCheck[$use] = $open; } } } foreach ($bracketsToCheck as $stackPtr => $openBracket) { // If the first argument is on a new line, this is a multi-line // function declaration, even if there is only one argument. $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($openBracket + 1), null, true); if ($tokens[$next]['line'] !== $tokens[$stackPtr]['line']) { return true; } $closeBracket = $tokens[$openBracket]['parenthesis_closer']; $end = $phpcsFile->findEndOfStatement($openBracket + 1); while ($tokens[$end]['code'] === T_COMMA) { // If the next bit of code is not on the same line, this is a // multi-line function declaration. $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($end + 1), $closeBracket, true); if ($next === false) { continue(2); } if ($tokens[$next]['line'] !== $tokens[$end]['line']) { return true; } $end = $phpcsFile->findEndOfStatement($next); } // We've reached the last argument, so see if the next content // (should be the close bracket) is also on the same line. $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($end + 1), $closeBracket, true); if ($next !== false && $tokens[$next]['line'] !== $tokens[$end]['line']) { return true; } }//end foreach return false; }//end isMultiLineDeclaration() /** * Processes single-line declarations. * * Just uses the Generic BSD-Allman brace sniff. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param array $tokens The stack of tokens that make up * the file. * * @return void */ public function processSingleLineDeclaration($phpcsFile, $stackPtr, $tokens) { // We do everything the parent sniff does, and a bit more because we // define multi-line declarations a bit differently. parent::processSingleLineDeclaration($phpcsFile, $stackPtr, $tokens); $openingBracket = $tokens[$stackPtr]['parenthesis_opener']; $closingBracket = $tokens[$stackPtr]['parenthesis_closer']; $prevNonWhiteSpace = $phpcsFile->findPrevious(T_WHITESPACE, ($closingBracket - 1), $openingBracket, true); if ($tokens[$prevNonWhiteSpace]['line'] !== $tokens[$closingBracket]['line']) { $error = 'There must not be a newline before the closing parenthesis of a single-line function declaration'; if (isset(Tokens::$emptyTokens[$tokens[$prevNonWhiteSpace]['code']]) === true) { $phpcsFile->addError($error, $closingBracket, 'CloseBracketNewLine'); } else { $fix = $phpcsFile->addFixableError($error, $closingBracket, 'CloseBracketNewLine'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($closingBracket - 1); $i > $openingBracket; $i--) { if ($tokens[$i]['code'] !== T_WHITESPACE) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } } }//end if }//end processSingleLineDeclaration() /** * Processes multi-line declarations. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param array $tokens The stack of tokens that make up * the file. * * @return void */ public function processMultiLineDeclaration($phpcsFile, $stackPtr, $tokens) { // We do everything the parent sniff does, and a bit more. parent::processMultiLineDeclaration($phpcsFile, $stackPtr, $tokens); $openBracket = $tokens[$stackPtr]['parenthesis_opener']; $this->processBracket($phpcsFile, $openBracket, $tokens, 'function'); if ($tokens[$stackPtr]['code'] !== T_CLOSURE) { return; } $use = $phpcsFile->findNext(T_USE, ($tokens[$stackPtr]['parenthesis_closer'] + 1), $tokens[$stackPtr]['scope_opener']); if ($use === false) { return; } $openBracket = $phpcsFile->findNext(T_OPEN_PARENTHESIS, ($use + 1), null); $this->processBracket($phpcsFile, $openBracket, $tokens, 'use'); }//end processMultiLineDeclaration() /** * Processes the contents of a single set of brackets. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $openBracket The position of the open bracket * in the stack passed in $tokens. * @param array $tokens The stack of tokens that make up * the file. * @param string $type The type of the token the brackets * belong to (function or use). * * @return void */ public function processBracket($phpcsFile, $openBracket, $tokens, $type='function') { $errorPrefix = ''; if ($type === 'use') { $errorPrefix = 'Use'; } $closeBracket = $tokens[$openBracket]['parenthesis_closer']; // The open bracket should be the last thing on the line. if ($tokens[$openBracket]['line'] !== $tokens[$closeBracket]['line']) { $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($openBracket + 1), null, true); if ($tokens[$next]['line'] !== ($tokens[$openBracket]['line'] + 1)) { $error = 'The first parameter of a multi-line '.$type.' declaration must be on the line after the opening bracket'; $fix = $phpcsFile->addFixableError($error, $next, $errorPrefix.'FirstParamSpacing'); if ($fix === true) { if ($tokens[$next]['line'] === $tokens[$openBracket]['line']) { $phpcsFile->fixer->addNewline($openBracket); } else { $phpcsFile->fixer->beginChangeset(); for ($x = $openBracket; $x < $next; $x++) { if ($tokens[$x]['line'] === $tokens[$openBracket]['line']) { continue; } if ($tokens[$x]['line'] === $tokens[$next]['line']) { break; } } $phpcsFile->fixer->endChangeset(); } } }//end if }//end if // Each line between the brackets should contain a single parameter. $lastComma = null; for ($i = ($openBracket + 1); $i < $closeBracket; $i++) { // Skip brackets, like arrays, as they can contain commas. if (isset($tokens[$i]['bracket_opener']) === true) { $i = $tokens[$i]['bracket_closer']; continue; } if (isset($tokens[$i]['parenthesis_opener']) === true) { $i = $tokens[$i]['parenthesis_closer']; continue; } if ($tokens[$i]['code'] !== T_COMMA) { continue; } $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($i + 1), null, true); if ($tokens[$next]['line'] === $tokens[$i]['line']) { $error = 'Multi-line '.$type.' declarations must define one parameter per line'; $fix = $phpcsFile->addFixableError($error, $next, $errorPrefix.'OneParamPerLine'); if ($fix === true) { $phpcsFile->fixer->addNewline($i); } } }//end for }//end processBracket() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/NamingConventions/ValidFunctionNameSniff.php0000644000076500000240000000345513614652362032105 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\NamingConventions; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Standards\PEAR\Sniffs\NamingConventions\ValidFunctionNameSniff as PEARValidFunctionNameSniff; use PHP_CodeSniffer\Util\Common; class ValidFunctionNameSniff extends PEARValidFunctionNameSniff { /** * Processes the tokens outside the scope. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being processed. * @param int $stackPtr The position where this token was * found. * * @return void */ protected function processTokenOutsideScope(File $phpcsFile, $stackPtr) { $functionName = $phpcsFile->getDeclarationName($stackPtr); if ($functionName === null) { return; } $errorData = [$functionName]; // Does this function claim to be magical? if (preg_match('|^__[^_]|', $functionName) !== 0) { $error = 'Function name "%s" is invalid; only PHP magic methods should be prefixed with a double underscore'; $phpcsFile->addError($error, $stackPtr, 'DoubleUnderscore', $errorData); $functionName = ltrim($functionName, '_'); } if (Common::isCamelCaps($functionName, false, true, false) === false) { $error = 'Function name "%s" is not in camel caps format'; $phpcsFile->addError($error, $stackPtr, 'NotCamelCaps', $errorData); } }//end processTokenOutsideScope() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/NamingConventions/ValidVariableNameSniff.php0000644000076500000240000001575713614652362032055 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\NamingConventions; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\AbstractVariableSniff; use PHP_CodeSniffer\Util\Common; use PHP_CodeSniffer\Util\Tokens; class ValidVariableNameSniff extends AbstractVariableSniff { /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ protected function processVariable(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $varName = ltrim($tokens[$stackPtr]['content'], '$'); // If it's a php reserved var, then its ok. if (isset($this->phpReservedVars[$varName]) === true) { return; } $objOperator = $phpcsFile->findNext([T_WHITESPACE], ($stackPtr + 1), null, true); if ($tokens[$objOperator]['code'] === T_OBJECT_OPERATOR) { // Check to see if we are using a variable from an object. $var = $phpcsFile->findNext([T_WHITESPACE], ($objOperator + 1), null, true); if ($tokens[$var]['code'] === T_STRING) { $bracket = $phpcsFile->findNext([T_WHITESPACE], ($var + 1), null, true); if ($tokens[$bracket]['code'] !== T_OPEN_PARENTHESIS) { $objVarName = $tokens[$var]['content']; // There is no way for us to know if the var is public or // private, so we have to ignore a leading underscore if there is // one and just check the main part of the variable name. $originalVarName = $objVarName; if (substr($objVarName, 0, 1) === '_') { $objVarName = substr($objVarName, 1); } if (Common::isCamelCaps($objVarName, false, true, false) === false) { $error = 'Variable "%s" is not in valid camel caps format'; $data = [$originalVarName]; $phpcsFile->addError($error, $var, 'NotCamelCaps', $data); } }//end if }//end if }//end if // There is no way for us to know if the var is public or private, // so we have to ignore a leading underscore if there is one and just // check the main part of the variable name. $originalVarName = $varName; if (substr($varName, 0, 1) === '_') { $objOperator = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true); if ($tokens[$objOperator]['code'] === T_DOUBLE_COLON) { // The variable lives within a class, and is referenced like // this: MyClass::$_variable, so we don't know its scope. $inClass = true; } else { $inClass = $phpcsFile->hasCondition($stackPtr, Tokens::$ooScopeTokens); } if ($inClass === true) { $varName = substr($varName, 1); } } if (Common::isCamelCaps($varName, false, true, false) === false) { $error = 'Variable "%s" is not in valid camel caps format'; $data = [$originalVarName]; $phpcsFile->addError($error, $stackPtr, 'NotCamelCaps', $data); } }//end processVariable() /** * Processes class member variables. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ protected function processMemberVar(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $varName = ltrim($tokens[$stackPtr]['content'], '$'); $memberProps = $phpcsFile->getMemberProperties($stackPtr); if (empty($memberProps) === true) { // Couldn't get any info about this variable, which // generally means it is invalid or possibly has a parse // error. Any errors will be reported by the core, so // we can ignore it. return; } $public = ($memberProps['scope'] !== 'private'); $errorData = [$varName]; if ($public === true) { if (substr($varName, 0, 1) === '_') { $error = '%s member variable "%s" must not contain a leading underscore'; $data = [ ucfirst($memberProps['scope']), $errorData[0], ]; $phpcsFile->addError($error, $stackPtr, 'PublicHasUnderscore', $data); } } else { if (substr($varName, 0, 1) !== '_') { $error = 'Private member variable "%s" must contain a leading underscore'; $phpcsFile->addError($error, $stackPtr, 'PrivateNoUnderscore', $errorData); } } // Remove a potential underscore prefix for testing CamelCaps. $varName = ltrim($varName, '_'); if (Common::isCamelCaps($varName, false, true, false) === false) { $error = 'Member variable "%s" is not in valid camel caps format'; $phpcsFile->addError($error, $stackPtr, 'MemberNotCamelCaps', $errorData); } }//end processMemberVar() /** * Processes the variable found within a double quoted string. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the double quoted * string. * * @return void */ protected function processVariableInString(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (preg_match_all('|[^\\\]\${?([a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)|', $tokens[$stackPtr]['content'], $matches) !== 0) { foreach ($matches[1] as $varName) { // If it's a php reserved var, then its ok. if (isset($this->phpReservedVars[$varName]) === true) { continue; } if (Common::isCamelCaps($varName, false, true, false) === false) { $error = 'Variable "%s" is not in valid camel caps format'; $data = [$varName]; $phpcsFile->addError($error, $stackPtr, 'StringNotCamelCaps', $data); } } } }//end processVariableInString() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Objects/DisallowObjectStringIndexSniff.php0000644000076500000240000000470213614652362031551 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Objects; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class DisallowObjectStringIndexSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['JS']; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_OPEN_SQUARE_BRACKET]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Check if the next non whitespace token is a string. $index = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($tokens[$index]['code'] !== T_CONSTANT_ENCAPSED_STRING) { return; } // Make sure it is the only thing in the square brackets. $next = $phpcsFile->findNext(T_WHITESPACE, ($index + 1), null, true); if ($tokens[$next]['code'] !== T_CLOSE_SQUARE_BRACKET) { return; } // Allow indexes that have dots in them because we can't write // them in dot notation. $content = trim($tokens[$index]['content'], '"\' '); if (strpos($content, '.') !== false) { return; } // Also ignore reserved words. if ($content === 'super') { return; } // Token before the opening square bracket cannot be a var name. $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true); if ($tokens[$prev]['code'] === T_STRING) { $error = 'Object indexes must be written in dot notation'; $phpcsFile->addError($error, $prev, 'Found'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Objects/ObjectInstantiationSniff.php0000644000076500000240000000347213614652362030443 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Objects; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class ObjectInstantiationSniff implements Sniff { /** * Registers the token types that this sniff wishes to listen to. * * @return array */ public function register() { return [T_NEW]; }//end register() /** * Process the tokens that this sniff is listening for. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $allowedTokens = Tokens::$emptyTokens; $allowedTokens[] = T_BITWISE_AND; $prev = $phpcsFile->findPrevious($allowedTokens, ($stackPtr - 1), null, true); $allowedTokens = [ T_EQUAL => true, T_DOUBLE_ARROW => true, T_THROW => true, T_RETURN => true, T_INLINE_THEN => true, T_INLINE_ELSE => true, ]; if (isset($allowedTokens[$tokens[$prev]['code']]) === false) { $error = 'New objects must be assigned to a variable'; $phpcsFile->addError($error, $stackPtr, 'NotAssigned'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Objects/ObjectMemberCommaSniff.php0000644000076500000240000000333213614652362027776 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Objects; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class ObjectMemberCommaSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['JS']; /** * Registers the token types that this sniff wishes to listen to. * * @return array */ public function register() { return [T_CLOSE_OBJECT]; }//end register() /** * Process the tokens that this sniff is listening for. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); if ($tokens[$prev]['code'] === T_COMMA) { $error = 'Last member of object must not be followed by a comma'; $fix = $phpcsFile->addFixableError($error, $prev, 'Found'); if ($fix === true) { $phpcsFile->fixer->replaceToken($prev, ''); } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Operators/ComparisonOperatorUsageSniff.php0000644000076500000240000002007713614652362031670 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Operators; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class ComparisonOperatorUsageSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * A list of valid comparison operators. * * @var array */ private static $validOps = [ T_IS_IDENTICAL => true, T_IS_NOT_IDENTICAL => true, T_LESS_THAN => true, T_GREATER_THAN => true, T_IS_GREATER_OR_EQUAL => true, T_IS_SMALLER_OR_EQUAL => true, T_INSTANCEOF => true, ]; /** * A list of invalid operators with their alternatives. * * @var array */ private static $invalidOps = [ 'PHP' => [ T_IS_EQUAL => '===', T_IS_NOT_EQUAL => '!==', T_BOOLEAN_NOT => '=== FALSE', ], 'JS' => [ T_IS_EQUAL => '===', T_IS_NOT_EQUAL => '!==', ], ]; /** * Registers the token types that this sniff wishes to listen to. * * @return array */ public function register() { return [ T_IF, T_ELSEIF, T_INLINE_THEN, T_WHILE, T_FOR, ]; }//end register() /** * Process the tokens that this sniff is listening for. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where the token * was found. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $tokenizer = $phpcsFile->tokenizerType; if ($tokens[$stackPtr]['code'] === T_INLINE_THEN) { $end = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); if ($tokens[$end]['code'] !== T_CLOSE_PARENTHESIS) { // This inline IF statement does not have its condition // bracketed, so we need to guess where it starts. for ($i = ($end - 1); $i >= 0; $i--) { if ($tokens[$i]['code'] === T_SEMICOLON) { // Stop here as we assume it is the end // of the previous statement. break; } else if ($tokens[$i]['code'] === T_OPEN_TAG) { // Stop here as this is the start of the file. break; } else if ($tokens[$i]['code'] === T_CLOSE_CURLY_BRACKET) { // Stop if this is the closing brace of // a code block. if (isset($tokens[$i]['scope_opener']) === true) { break; } } else if ($tokens[$i]['code'] === T_OPEN_CURLY_BRACKET) { // Stop if this is the opening brace of // a code block. if (isset($tokens[$i]['scope_closer']) === true) { break; } } else if ($tokens[$i]['code'] === T_OPEN_PARENTHESIS) { // Stop if this is the start of a pair of // parentheses that surrounds the inline // IF statement. if (isset($tokens[$i]['parenthesis_closer']) === true && $tokens[$i]['parenthesis_closer'] >= $stackPtr ) { break; } }//end if }//end for $start = $phpcsFile->findNext(Tokens::$emptyTokens, ($i + 1), null, true); } else { if (isset($tokens[$end]['parenthesis_opener']) === false) { return; } $start = $tokens[$end]['parenthesis_opener']; }//end if } else if ($tokens[$stackPtr]['code'] === T_FOR) { if (isset($tokens[$stackPtr]['parenthesis_opener']) === false) { return; } $openingBracket = $tokens[$stackPtr]['parenthesis_opener']; $closingBracket = $tokens[$stackPtr]['parenthesis_closer']; $start = $phpcsFile->findNext(T_SEMICOLON, $openingBracket, $closingBracket); $end = $phpcsFile->findNext(T_SEMICOLON, ($start + 1), $closingBracket); if ($start === false || $end === false) { return; } } else { if (isset($tokens[$stackPtr]['parenthesis_opener']) === false) { return; } $start = $tokens[$stackPtr]['parenthesis_opener']; $end = $tokens[$stackPtr]['parenthesis_closer']; }//end if $requiredOps = 0; $foundOps = 0; $foundBooleans = 0; $lastNonEmpty = $start; for ($i = $start; $i <= $end; $i++) { $type = $tokens[$i]['code']; if (isset(self::$invalidOps[$tokenizer][$type]) === true) { $error = 'Operator %s prohibited; use %s instead'; $data = [ $tokens[$i]['content'], self::$invalidOps[$tokenizer][$type], ]; $phpcsFile->addError($error, $i, 'NotAllowed', $data); $foundOps++; } else if (isset(self::$validOps[$type]) === true) { $foundOps++; } if ($type === T_OPEN_PARENTHESIS && isset($tokens[$i]['parenthesis_closer']) === true && isset(Tokens::$functionNameTokens[$tokens[$lastNonEmpty]['code']]) === true ) { $i = $tokens[$i]['parenthesis_closer']; $lastNonEmpty = $i; continue; } if ($tokens[$i]['code'] === T_TRUE || $tokens[$i]['code'] === T_FALSE) { $foundBooleans++; } if ($phpcsFile->tokenizerType !== 'JS' && ($tokens[$i]['code'] === T_BOOLEAN_AND || $tokens[$i]['code'] === T_BOOLEAN_OR) ) { $requiredOps++; // When the instanceof operator is used with another operator // like ===, you can get more ops than are required. if ($foundOps > $requiredOps) { $foundOps = $requiredOps; } // If we get to here and we have not found the right number of // comparison operators, then we must have had an implicit // true operation i.e., if ($a) instead of the required // if ($a === true), so let's add an error. if ($requiredOps !== $foundOps) { $error = 'Implicit true comparisons prohibited; use === TRUE instead'; $phpcsFile->addError($error, $stackPtr, 'ImplicitTrue'); $foundOps++; } } if (isset(Tokens::$emptyTokens[$type]) === false) { $lastNonEmpty = $i; } }//end for $requiredOps++; if ($phpcsFile->tokenizerType !== 'JS' && $foundOps < $requiredOps && ($requiredOps !== $foundBooleans) ) { $error = 'Implicit true comparisons prohibited; use === TRUE instead'; $phpcsFile->addError($error, $stackPtr, 'ImplicitTrue'); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Operators/IncrementDecrementUsageSniff.php0000644000076500000240000001721513614652362031615 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Operators; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class IncrementDecrementUsageSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_EQUAL, T_PLUS_EQUAL, T_MINUS_EQUAL, T_INC, T_DEC, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if ($tokens[$stackPtr]['code'] === T_INC || $tokens[$stackPtr]['code'] === T_DEC) { $this->processIncDec($phpcsFile, $stackPtr); } else { $this->processAssignment($phpcsFile, $stackPtr); } }//end process() /** * Checks to ensure increment and decrement operators are not confusing. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ protected function processIncDec($phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Work out where the variable is so we know where to // start looking for other operators. if ($tokens[($stackPtr - 1)]['code'] === T_VARIABLE || ($tokens[($stackPtr - 1)]['code'] === T_STRING && $tokens[($stackPtr - 2)]['code'] === T_OBJECT_OPERATOR) ) { $start = ($stackPtr + 1); } else { $start = ($stackPtr + 2); } $next = $phpcsFile->findNext(Tokens::$emptyTokens, $start, null, true); if ($next === false) { return; } if (isset(Tokens::$arithmeticTokens[$tokens[$next]['code']]) === true) { $error = 'Increment and decrement operators cannot be used in an arithmetic operation'; $phpcsFile->addError($error, $stackPtr, 'NotAllowed'); return; } $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($start - 3), null, true); if ($prev === false) { return; } // Check if this is in a string concat. if ($tokens[$next]['code'] === T_STRING_CONCAT || $tokens[$prev]['code'] === T_STRING_CONCAT) { $error = 'Increment and decrement operators must be bracketed when used in string concatenation'; $phpcsFile->addError($error, $stackPtr, 'NoBrackets'); } }//end processIncDec() /** * Checks to ensure increment and decrement operators are used. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ protected function processAssignment($phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $assignedVar = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true); // Not an assignment, return. if ($tokens[$assignedVar]['code'] !== T_VARIABLE) { return; } $statementEnd = $phpcsFile->findNext([T_SEMICOLON, T_CLOSE_PARENTHESIS, T_CLOSE_SQUARE_BRACKET, T_CLOSE_CURLY_BRACKET], $stackPtr); // If there is anything other than variables, numbers, spaces or operators we need to return. $noiseTokens = $phpcsFile->findNext([T_LNUMBER, T_VARIABLE, T_WHITESPACE, T_PLUS, T_MINUS, T_OPEN_PARENTHESIS], ($stackPtr + 1), $statementEnd, true); if ($noiseTokens !== false) { return; } // If we are already using += or -=, we need to ignore // the statement if a variable is being used. if ($tokens[$stackPtr]['code'] !== T_EQUAL) { $nextVar = $phpcsFile->findNext(T_VARIABLE, ($stackPtr + 1), $statementEnd); if ($nextVar !== false) { return; } } if ($tokens[$stackPtr]['code'] === T_EQUAL) { $nextVar = ($stackPtr + 1); $previousVariable = ($stackPtr + 1); $variableCount = 0; while (($nextVar = $phpcsFile->findNext(T_VARIABLE, ($nextVar + 1), $statementEnd)) !== false) { $previousVariable = $nextVar; $variableCount++; } if ($variableCount !== 1) { return; } $nextVar = $previousVariable; if ($tokens[$nextVar]['content'] !== $tokens[$assignedVar]['content']) { return; } } // We have only one variable, and it's the same as what is being assigned, // so we need to check what is being added or subtracted. $nextNumber = ($stackPtr + 1); $previousNumber = ($stackPtr + 1); $numberCount = 0; while (($nextNumber = $phpcsFile->findNext([T_LNUMBER], ($nextNumber + 1), $statementEnd, false)) !== false) { $previousNumber = $nextNumber; $numberCount++; } if ($numberCount !== 1) { return; } $nextNumber = $previousNumber; if ($tokens[$nextNumber]['content'] === '1') { if ($tokens[$stackPtr]['code'] === T_EQUAL) { $opToken = $phpcsFile->findNext([T_PLUS, T_MINUS], ($nextVar + 1), $statementEnd); if ($opToken === false) { // Operator was before the variable, like: // $var = 1 + $var; // So we ignore it. return; } $operator = $tokens[$opToken]['content']; } else { $operator = substr($tokens[$stackPtr]['content'], 0, 1); } // If we are adding or subtracting negative value, the operator // needs to be reversed. if ($tokens[$stackPtr]['code'] !== T_EQUAL) { $negative = $phpcsFile->findPrevious(T_MINUS, ($nextNumber - 1), $stackPtr); if ($negative !== false) { if ($operator === '+') { $operator = '-'; } else { $operator = '+'; } } } $expected = $operator.$operator.$tokens[$assignedVar]['content']; $found = $phpcsFile->getTokensAsString($assignedVar, ($statementEnd - $assignedVar + 1)); if ($operator === '+') { $error = 'Increment'; } else { $error = 'Decrement'; } $error .= " operators should be used where possible; found \"$found\" but expected \"$expected\""; $phpcsFile->addError($error, $stackPtr, 'Found'); }//end if }//end processAssignment() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Operators/ValidLogicalOperatorsSniff.php0000644000076500000240000000325513614652362031305 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Operators; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class ValidLogicalOperatorsSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_LOGICAL_AND, T_LOGICAL_OR, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $replacements = [ 'and' => '&&', 'or' => '||', ]; $operator = strtolower($tokens[$stackPtr]['content']); if (isset($replacements[$operator]) === false) { return; } $error = 'Logical operator "%s" is prohibited; use "%s" instead'; $data = [ $operator, $replacements[$operator], ]; $phpcsFile->addError($error, $stackPtr, 'NotAllowed', $data); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/PHP/CommentedOutCodeSniff.php0000644000076500000240000002262213614652362026722 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\PHP; use PHP_CodeSniffer\Exceptions\TokenizerException; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class CommentedOutCodeSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'CSS', ]; /** * If a comment is more than $maxPercentage% code, a warning will be shown. * * @var integer */ public $maxPercentage = 35; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_COMMENT]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return int|void Integer stack pointer to skip forward or void to continue * normal file processing. */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Ignore comments at the end of code blocks. if (substr($tokens[$stackPtr]['content'], 0, 6) === '//end ') { return; } $content = ''; $lastLineSeen = $tokens[$stackPtr]['line']; $commentStyle = 'line'; if (strpos($tokens[$stackPtr]['content'], '/*') === 0) { $commentStyle = 'block'; } $lastCommentBlockToken = $stackPtr; for ($i = $stackPtr; $i < $phpcsFile->numTokens; $i++) { if (isset(Tokens::$emptyTokens[$tokens[$i]['code']]) === false) { break; } if ($tokens[$i]['code'] === T_WHITESPACE) { continue; } if (isset(Tokens::$phpcsCommentTokens[$tokens[$i]['code']]) === true) { $lastLineSeen = $tokens[$i]['line']; continue; } if ($commentStyle === 'line' && ($lastLineSeen + 1) <= $tokens[$i]['line'] && strpos($tokens[$i]['content'], '/*') === 0 ) { // First non-whitespace token on a new line is start of a different style comment. break; } if ($commentStyle === 'line' && ($lastLineSeen + 1) < $tokens[$i]['line'] ) { // Blank line breaks a '//' style comment block. break; } /* Trim as much off the comment as possible so we don't have additional whitespace tokens or comment tokens */ $tokenContent = trim($tokens[$i]['content']); $break = false; if ($commentStyle === 'line') { if (substr($tokenContent, 0, 2) === '//') { $tokenContent = substr($tokenContent, 2); } if (substr($tokenContent, 0, 1) === '#') { $tokenContent = substr($tokenContent, 1); } } else { if (substr($tokenContent, 0, 3) === '/**') { $tokenContent = substr($tokenContent, 3); } if (substr($tokenContent, 0, 2) === '/*') { $tokenContent = substr($tokenContent, 2); } if (substr($tokenContent, -2) === '*/') { $tokenContent = substr($tokenContent, 0, -2); $break = true; } if (substr($tokenContent, 0, 1) === '*') { $tokenContent = substr($tokenContent, 1); } }//end if $content .= $tokenContent.$phpcsFile->eolChar; $lastLineSeen = $tokens[$i]['line']; $lastCommentBlockToken = $i; if ($break === true) { // Closer of a block comment found. break; } }//end for // Ignore typical warning suppression annotations from other tools. if (preg_match('`^\s*@[A-Za-z()\._-]+\s*$`', $content) === 1) { return ($lastCommentBlockToken + 1); } // Quite a few comments use multiple dashes, equals signs etc // to frame comments and licence headers. $content = preg_replace('/[-=#*]{2,}/', '-', $content); // Random numbers sitting inside the content can throw parse errors // for invalid literals in PHP7+, so strip those. $content = preg_replace('/\d+/', '', $content); $content = trim($content); if ($content === '') { return ($lastCommentBlockToken + 1); } if ($phpcsFile->tokenizerType === 'PHP') { $content = ''; } // Because we are not really parsing code, the tokenizer can throw all sorts // of errors that don't mean anything, so ignore them. $oldErrors = ini_get('error_reporting'); ini_set('error_reporting', 0); try { $tokenizerClass = get_class($phpcsFile->tokenizer); $tokenizer = new $tokenizerClass($content, $phpcsFile->config, $phpcsFile->eolChar); $stringTokens = $tokenizer->getTokens(); } catch (TokenizerException $e) { // We couldn't check the comment, so ignore it. ini_set('error_reporting', $oldErrors); return ($lastCommentBlockToken + 1); } ini_set('error_reporting', $oldErrors); $numTokens = count($stringTokens); /* We know what the first two and last two tokens should be (because we put them there) so ignore this comment if those tokens were not parsed correctly. It obviously means this is not valid code. */ // First token is always the opening tag. if ($stringTokens[0]['code'] !== T_OPEN_TAG) { return ($lastCommentBlockToken + 1); } else { array_shift($stringTokens); --$numTokens; } // Last token is always the closing tag, unless something went wrong. if (isset($stringTokens[($numTokens - 1)]) === false || $stringTokens[($numTokens - 1)]['code'] !== T_CLOSE_TAG ) { return ($lastCommentBlockToken + 1); } else { array_pop($stringTokens); --$numTokens; } // Second last token is always whitespace or a comment, depending // on the code inside the comment. if ($phpcsFile->tokenizerType === 'PHP') { if (isset(Tokens::$emptyTokens[$stringTokens[($numTokens - 1)]['code']]) === false) { return ($lastCommentBlockToken + 1); } if ($stringTokens[($numTokens - 1)]['code'] === T_WHITESPACE) { array_pop($stringTokens); --$numTokens; } } $emptyTokens = [ T_WHITESPACE => true, T_STRING => true, T_STRING_CONCAT => true, T_ENCAPSED_AND_WHITESPACE => true, T_NONE => true, T_COMMENT => true, ]; $emptyTokens += Tokens::$phpcsCommentTokens; $numComment = 0; $numPossible = 0; $numCode = 0; $numNonWhitespace = 0; for ($i = 0; $i < $numTokens; $i++) { if (isset($emptyTokens[$stringTokens[$i]['code']]) === true) { // Looks like comment. $numComment++; } else if (isset(Tokens::$comparisonTokens[$stringTokens[$i]['code']]) === true || isset(Tokens::$arithmeticTokens[$stringTokens[$i]['code']]) === true || $stringTokens[$i]['code'] === T_GOTO_LABEL ) { // Commented out HTML/XML and other docs contain a lot of these // characters, so it is best to not use them directly. $numPossible++; } else { // Looks like code. $numCode++; } if ($stringTokens[$i]['code'] !== T_WHITESPACE) { ++$numNonWhitespace; } } // Ignore comments with only two or less non-whitespace tokens. // Sample size too small for a reliably determination. if ($numNonWhitespace <= 2) { return ($lastCommentBlockToken + 1); } $percentCode = ceil((($numCode / $numTokens) * 100)); if ($percentCode > $this->maxPercentage) { // Just in case. $percentCode = min(100, $percentCode); $error = 'This comment is %s%% valid code; is this commented out code?'; $data = [$percentCode]; $phpcsFile->addWarning($error, $stackPtr, 'Found', $data); } return ($lastCommentBlockToken + 1); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/PHP/DisallowBooleanStatementSniff.php0000644000076500000240000000335113614652362030465 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\PHP; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class DisallowBooleanStatementSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return Tokens::$booleanOperators; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['nested_parenthesis']) === true) { foreach ($tokens[$stackPtr]['nested_parenthesis'] as $open => $close) { if (isset($tokens[$open]['parenthesis_owner']) === true) { // Any owner means we are not just a simple statement. return; } } } $error = 'Boolean operators are not allowed outside of control structure conditions'; $phpcsFile->addError($error, $stackPtr, 'Found'); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/PHP/DisallowComparisonAssignmentSniff.php0000644000076500000240000000637513614652362031375 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\PHP; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class DisallowComparisonAssignmentSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_EQUAL]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Ignore default value assignments in function definitions. $function = $phpcsFile->findPrevious(T_FUNCTION, ($stackPtr - 1), null, false, null, true); if ($function !== false) { $opener = $tokens[$function]['parenthesis_opener']; $closer = $tokens[$function]['parenthesis_closer']; if ($opener < $stackPtr && $closer > $stackPtr) { return; } } // Ignore values in array definitions. $array = $phpcsFile->findNext( T_ARRAY, ($stackPtr + 1), null, false, null, true ); if ($array !== false) { return; } // Ignore function calls. $ignore = [ T_STRING, T_WHITESPACE, T_OBJECT_OPERATOR, ]; $next = $phpcsFile->findNext($ignore, ($stackPtr + 1), null, true); if ($tokens[$next]['code'] === T_OPEN_PARENTHESIS && $tokens[($next - 1)]['code'] === T_STRING ) { // Code will look like: $var = myFunction( // and will be ignored. return; } $endStatement = $phpcsFile->findEndOfStatement($stackPtr); for ($i = ($stackPtr + 1); $i < $endStatement; $i++) { if ((isset(Tokens::$comparisonTokens[$tokens[$i]['code']]) === true && $tokens[$i]['code'] !== T_COALESCE) || $tokens[$i]['code'] === T_INLINE_THEN ) { $error = 'The value of a comparison must not be assigned to a variable'; $phpcsFile->addError($error, $stackPtr, 'AssignedComparison'); break; } if (isset(Tokens::$booleanOperators[$tokens[$i]['code']]) === true || $tokens[$i]['code'] === T_BOOLEAN_NOT ) { $error = 'The value of a boolean operation must not be assigned to a variable'; $phpcsFile->addError($error, $stackPtr, 'AssignedBool'); break; } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/PHP/DisallowInlineIfSniff.php0000644000076500000240000000252113614652362026714 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\PHP; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class DisallowInlineIfSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_INLINE_THEN]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $phpcsFile->addError('Inline IF statements are not allowed', $stackPtr, 'Found'); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/PHP/DisallowMultipleAssignmentsSniff.php0000644000076500000240000001442713614652362031236 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\PHP; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class DisallowMultipleAssignmentsSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_EQUAL]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Ignore default value assignments in function definitions. $function = $phpcsFile->findPrevious([T_FUNCTION, T_CLOSURE], ($stackPtr - 1), null, false, null, true); if ($function !== false) { $opener = $tokens[$function]['parenthesis_opener']; $closer = $tokens[$function]['parenthesis_closer']; if ($opener < $stackPtr && $closer > $stackPtr) { return; } } // Ignore assignments in WHILE loop conditions. if (isset($tokens[$stackPtr]['nested_parenthesis']) === true) { $nested = $tokens[$stackPtr]['nested_parenthesis']; foreach ($nested as $opener => $closer) { if (isset($tokens[$opener]['parenthesis_owner']) === true && $tokens[$tokens[$opener]['parenthesis_owner']]['code'] === T_WHILE ) { return; } } } /* The general rule is: Find an equal sign and go backwards along the line. If you hit an end bracket, skip to the opening bracket. When you find a variable, stop. That variable must be the first non-empty token on the line or in the statement. If not, throw an error. */ for ($varToken = ($stackPtr - 1); $varToken >= 0; $varToken--) { // Skip brackets. if (isset($tokens[$varToken]['parenthesis_opener']) === true && $tokens[$varToken]['parenthesis_opener'] < $varToken) { $varToken = $tokens[$varToken]['parenthesis_opener']; continue; } if (isset($tokens[$varToken]['bracket_opener']) === true) { $varToken = $tokens[$varToken]['bracket_opener']; continue; } if ($tokens[$varToken]['code'] === T_SEMICOLON) { // We've reached the next statement, so we // didn't find a variable. return; } if ($tokens[$varToken]['code'] === T_VARIABLE) { // We found our variable. break; } }//end for if ($varToken <= 0) { // Didn't find a variable. return; } $start = $phpcsFile->findStartOfStatement($varToken); $allowed = Tokens::$emptyTokens; $allowed[T_STRING] = T_STRING; $allowed[T_NS_SEPARATOR] = T_NS_SEPARATOR; $allowed[T_DOUBLE_COLON] = T_DOUBLE_COLON; $allowed[T_OBJECT_OPERATOR] = T_OBJECT_OPERATOR; $allowed[T_ASPERAND] = T_ASPERAND; $allowed[T_DOLLAR] = T_DOLLAR; $allowed[T_SELF] = T_SELF; $allowed[T_PARENT] = T_PARENT; $allowed[T_STATIC] = T_STATIC; $varToken = $phpcsFile->findPrevious($allowed, ($varToken - 1), null, true); if ($varToken < $start && $tokens[$varToken]['code'] !== T_OPEN_PARENTHESIS && $tokens[$varToken]['code'] !== T_OPEN_SQUARE_BRACKET ) { $varToken = $start; } // Ignore member var definitions. if (isset(Tokens::$scopeModifiers[$tokens[$varToken]['code']]) === true || $tokens[$varToken]['code'] === T_VAR || $tokens[$varToken]['code'] === T_STATIC ) { return; } // Ignore the first part of FOR loops as we are allowed to // assign variables there even though the variable is not the // first thing on the line. if ($tokens[$varToken]['code'] === T_OPEN_PARENTHESIS && isset($tokens[$varToken]['parenthesis_owner']) === true) { $owner = $tokens[$varToken]['parenthesis_owner']; if ($tokens[$owner]['code'] === T_FOR) { return; } } if ($tokens[$varToken]['code'] === T_VARIABLE || $tokens[$varToken]['code'] === T_OPEN_TAG || $tokens[$varToken]['code'] === T_INLINE_THEN || $tokens[$varToken]['code'] === T_INLINE_ELSE || $tokens[$varToken]['code'] === T_SEMICOLON || $tokens[$varToken]['code'] === T_CLOSE_PARENTHESIS || isset($allowed[$tokens[$varToken]['code']]) === true ) { return; } $error = 'Assignments must be the first block of code on a line'; $errorCode = 'Found'; if (isset($nested) === true) { $controlStructures = [ T_IF => T_IF, T_ELSEIF => T_ELSEIF, T_SWITCH => T_SWITCH, T_CASE => T_CASE, T_FOR => T_FOR, ]; foreach ($nested as $opener => $closer) { if (isset($tokens[$opener]['parenthesis_owner']) === true && isset($controlStructures[$tokens[$tokens[$opener]['parenthesis_owner']]['code']]) === true ) { $errorCode .= 'InControlStructure'; break; } } } $phpcsFile->addError($error, $stackPtr, $errorCode); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/PHP/DisallowSizeFunctionsInLoopsSniff.php0000644000076500000240000000671613614652362031340 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\PHP; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class DisallowSizeFunctionsInLoopsSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * An array of functions we don't want in the condition of loops. * * @var array */ protected $forbiddenFunctions = [ 'PHP' => [ 'sizeof' => true, 'strlen' => true, 'count' => true, ], 'JS' => ['length' => true], ]; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_WHILE, T_FOR, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $tokenizer = $phpcsFile->tokenizerType; $openBracket = $tokens[$stackPtr]['parenthesis_opener']; $closeBracket = $tokens[$stackPtr]['parenthesis_closer']; if ($tokens[$stackPtr]['code'] === T_FOR) { // We only want to check the condition in FOR loops. $start = $phpcsFile->findNext(T_SEMICOLON, ($openBracket + 1)); $end = $phpcsFile->findPrevious(T_SEMICOLON, ($closeBracket - 1)); } else { $start = $openBracket; $end = $closeBracket; } for ($i = ($start + 1); $i < $end; $i++) { if ($tokens[$i]['code'] === T_STRING && isset($this->forbiddenFunctions[$tokenizer][$tokens[$i]['content']]) === true ) { $functionName = $tokens[$i]['content']; if ($tokenizer === 'JS') { // Needs to be in the form object.function to be valid. $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($i - 1), null, true); if ($prev === false || $tokens[$prev]['code'] !== T_OBJECT_OPERATOR) { continue; } $functionName = 'object.'.$functionName; } else { // Make sure it isn't a member var. if ($tokens[($i - 1)]['code'] === T_OBJECT_OPERATOR) { continue; } $functionName .= '()'; } $error = 'The use of %s inside a loop condition is not allowed; assign the return value to a variable and use the variable in the loop condition instead'; $data = [$functionName]; $phpcsFile->addError($error, $i, 'Found', $data); }//end if }//end for }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/PHP/DiscouragedFunctionsSniff.php0000644000076500000240000000176213614652362027650 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\PHP; use PHP_CodeSniffer\Standards\Generic\Sniffs\PHP\ForbiddenFunctionsSniff as GenericForbiddenFunctionsSniff; class DiscouragedFunctionsSniff extends GenericForbiddenFunctionsSniff { /** * A list of forbidden functions with their alternatives. * * The value is NULL if no alternative exists. IE, the * function should just not be used. * * @var array */ public $forbiddenFunctions = [ 'error_log' => null, 'print_r' => null, 'var_dump' => null, ]; /** * If true, an error will be thrown; otherwise a warning. * * @var boolean */ public $error = false; }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/PHP/EmbeddedPhpSniff.php0000644000076500000240000004167113614652362025672 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\PHP; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class EmbeddedPhpSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // If the close php tag is on the same line as the opening // then we have an inline embedded PHP block. $closeTag = $phpcsFile->findNext(T_CLOSE_TAG, $stackPtr); if ($closeTag === false || $tokens[$stackPtr]['line'] !== $tokens[$closeTag]['line']) { $this->validateMultilineEmbeddedPhp($phpcsFile, $stackPtr); } else { $this->validateInlineEmbeddedPhp($phpcsFile, $stackPtr); } }//end process() /** * Validates embedded PHP that exists on multiple lines. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ private function validateMultilineEmbeddedPhp($phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $prevTag = $phpcsFile->findPrevious(T_OPEN_TAG, ($stackPtr - 1)); if ($prevTag === false) { // This is the first open tag. return; } $firstContent = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); $closingTag = $phpcsFile->findNext(T_CLOSE_TAG, $stackPtr); if ($closingTag !== false) { $nextContent = $phpcsFile->findNext(T_WHITESPACE, ($closingTag + 1), $phpcsFile->numTokens, true); if ($nextContent === false) { // Final closing tag. It will be handled elsewhere. return; } // We have an opening and a closing tag, that lie within other content. if ($firstContent === $closingTag) { $error = 'Empty embedded PHP tag found'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Empty'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = $stackPtr; $i <= $closingTag; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } return; } }//end if if ($tokens[$firstContent]['line'] === $tokens[$stackPtr]['line']) { $error = 'Opening PHP tag must be on a line by itself'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'ContentAfterOpen'); if ($fix === true) { $first = $phpcsFile->findFirstOnLine(T_WHITESPACE, $stackPtr, true); $padding = (strlen($tokens[$first]['content']) - strlen(ltrim($tokens[$first]['content']))); $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->addNewline($stackPtr); $phpcsFile->fixer->addContent($stackPtr, str_repeat(' ', $padding)); $phpcsFile->fixer->endChangeset(); } } else { // Check the indent of the first line, except if it is a scope closer. if (isset($tokens[$firstContent]['scope_closer']) === false || $tokens[$firstContent]['scope_closer'] !== $firstContent ) { // Check for a blank line at the top. if ($tokens[$firstContent]['line'] > ($tokens[$stackPtr]['line'] + 1)) { // Find a token on the blank line to throw the error on. $i = $stackPtr; do { $i++; } while ($tokens[$i]['line'] !== ($tokens[$stackPtr]['line'] + 1)); $error = 'Blank line found at start of embedded PHP content'; $fix = $phpcsFile->addFixableError($error, $i, 'SpacingBefore'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($stackPtr + 1); $i < $firstContent; $i++) { if ($tokens[$i]['line'] === $tokens[$firstContent]['line'] || $tokens[$i]['line'] === $tokens[$stackPtr]['line'] ) { continue; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } }//end if $first = $phpcsFile->findFirstOnLine(T_WHITESPACE, $stackPtr); if ($first === false) { $first = $phpcsFile->findFirstOnLine(T_INLINE_HTML, $stackPtr); $indent = (strlen($tokens[$first]['content']) - strlen(ltrim($tokens[$first]['content']))); } else { $indent = ($tokens[($first + 1)]['column'] - 1); } $contentColumn = ($tokens[$firstContent]['column'] - 1); if ($contentColumn !== $indent) { $error = 'First line of embedded PHP code must be indented %s spaces; %s found'; $data = [ $indent, $contentColumn, ]; $fix = $phpcsFile->addFixableError($error, $firstContent, 'Indent', $data); if ($fix === true) { $padding = str_repeat(' ', $indent); if ($contentColumn === 0) { $phpcsFile->fixer->addContentBefore($firstContent, $padding); } else { $phpcsFile->fixer->replaceToken(($firstContent - 1), $padding); } } } }//end if }//end if $lastContent = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true); if ($tokens[$lastContent]['line'] === $tokens[$stackPtr]['line'] && trim($tokens[$lastContent]['content']) !== '' ) { $error = 'Opening PHP tag must be on a line by itself'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'ContentBeforeOpen'); if ($fix === true) { $first = $phpcsFile->findFirstOnLine(T_WHITESPACE, $stackPtr); if ($first === false) { $first = $phpcsFile->findFirstOnLine(T_INLINE_HTML, $stackPtr); $padding = (strlen($tokens[$first]['content']) - strlen(ltrim($tokens[$first]['content']))); } else { $padding = ($tokens[($first + 1)]['column'] - 1); } $phpcsFile->fixer->addContentBefore($stackPtr, $phpcsFile->eolChar.str_repeat(' ', $padding)); } } else { // Find the first token on the first non-empty line we find. for ($first = ($stackPtr - 1); $first > 0; $first--) { if ($tokens[$first]['line'] === $tokens[$stackPtr]['line']) { continue; } else if (trim($tokens[$first]['content']) !== '') { $first = $phpcsFile->findFirstOnLine([], $first, true); break; } } $expected = 0; if ($tokens[$first]['code'] === T_INLINE_HTML && trim($tokens[$first]['content']) !== '' ) { $expected = (strlen($tokens[$first]['content']) - strlen(ltrim($tokens[$first]['content']))); } else if ($tokens[$first]['code'] === T_WHITESPACE) { $expected = ($tokens[($first + 1)]['column'] - 1); } $expected += 4; $found = ($tokens[$stackPtr]['column'] - 1); if ($found > $expected) { $error = 'Opening PHP tag indent incorrect; expected no more than %s spaces but found %s'; $data = [ $expected, $found, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'OpenTagIndent', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($stackPtr - 1), str_repeat(' ', $expected)); } } }//end if if ($closingTag === false) { return; } $lastContent = $phpcsFile->findPrevious(T_WHITESPACE, ($closingTag - 1), ($stackPtr + 1), true); $nextContent = $phpcsFile->findNext(T_WHITESPACE, ($closingTag + 1), null, true); if ($tokens[$lastContent]['line'] === $tokens[$closingTag]['line']) { $error = 'Closing PHP tag must be on a line by itself'; $fix = $phpcsFile->addFixableError($error, $closingTag, 'ContentBeforeEnd'); if ($fix === true) { $first = $phpcsFile->findFirstOnLine(T_WHITESPACE, $closingTag, true); $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->addContentBefore($closingTag, str_repeat(' ', ($tokens[$first]['column'] - 1))); $phpcsFile->fixer->addNewlineBefore($closingTag); $phpcsFile->fixer->endChangeset(); } } else if ($tokens[$nextContent]['line'] === $tokens[$closingTag]['line']) { $error = 'Closing PHP tag must be on a line by itself'; $fix = $phpcsFile->addFixableError($error, $closingTag, 'ContentAfterEnd'); if ($fix === true) { $first = $phpcsFile->findFirstOnLine(T_WHITESPACE, $closingTag, true); $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->addNewline($closingTag); $phpcsFile->fixer->addContent($closingTag, str_repeat(' ', ($tokens[$first]['column'] - 1))); $phpcsFile->fixer->endChangeset(); } }//end if $next = $phpcsFile->findNext(T_OPEN_TAG, ($closingTag + 1)); if ($next === false) { return; } // Check for a blank line at the bottom. if ((isset($tokens[$lastContent]['scope_closer']) === false || $tokens[$lastContent]['scope_closer'] !== $lastContent) && $tokens[$lastContent]['line'] < ($tokens[$closingTag]['line'] - 1) ) { // Find a token on the blank line to throw the error on. $i = $closingTag; do { $i--; } while ($tokens[$i]['line'] !== ($tokens[$closingTag]['line'] - 1)); $error = 'Blank line found at end of embedded PHP content'; $fix = $phpcsFile->addFixableError($error, $i, 'SpacingAfter'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($lastContent + 1); $i < $closingTag; $i++) { if ($tokens[$i]['line'] === $tokens[$lastContent]['line'] || $tokens[$i]['line'] === $tokens[$closingTag]['line'] ) { continue; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } }//end if }//end validateMultilineEmbeddedPhp() /** * Validates embedded PHP that exists on one line. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ private function validateInlineEmbeddedPhp($phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // We only want one line PHP sections, so return if the closing tag is // on the next line. $closeTag = $phpcsFile->findNext(T_CLOSE_TAG, $stackPtr, null, false); if ($tokens[$stackPtr]['line'] !== $tokens[$closeTag]['line']) { return; } // Check that there is one, and only one space at the start of the statement. $firstContent = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), $closeTag, true); if ($firstContent === false) { $error = 'Empty embedded PHP tag found'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Empty'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = $stackPtr; $i <= $closeTag; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } return; } // The open tag token always contains a single space after it. $leadingSpace = 1; if ($tokens[($stackPtr + 1)]['code'] === T_WHITESPACE) { $leadingSpace = ($tokens[($stackPtr + 1)]['length'] + 1); } if ($leadingSpace !== 1) { $error = 'Expected 1 space after opening PHP tag; %s found'; $data = [$leadingSpace]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpacingAfterOpen', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($stackPtr + 1), ''); } } $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($closeTag - 1), $stackPtr, true); if ($prev !== $stackPtr) { if ((isset($tokens[$prev]['scope_opener']) === false || $tokens[$prev]['scope_opener'] !== $prev) && (isset($tokens[$prev]['scope_closer']) === false || $tokens[$prev]['scope_closer'] !== $prev) && $tokens[$prev]['code'] !== T_SEMICOLON ) { $error = 'Inline PHP statement must end with a semicolon'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NoSemicolon'); if ($fix === true) { $phpcsFile->fixer->addContent($prev, ';'); } } else if ($tokens[$prev]['code'] === T_SEMICOLON) { $statementCount = 1; for ($i = ($stackPtr + 1); $i < $prev; $i++) { if ($tokens[$i]['code'] === T_SEMICOLON) { $statementCount++; } } if ($statementCount > 1) { $error = 'Inline PHP statement must contain a single statement; %s found'; $data = [$statementCount]; $phpcsFile->addError($error, $stackPtr, 'MultipleStatements', $data); } } }//end if $trailingSpace = 0; if ($tokens[($closeTag - 1)]['code'] === T_WHITESPACE) { $trailingSpace = $tokens[($closeTag - 1)]['length']; } else if (($tokens[($closeTag - 1)]['code'] === T_COMMENT || isset(Tokens::$phpcsCommentTokens[$tokens[($closeTag - 1)]['code']]) === true) && substr($tokens[($closeTag - 1)]['content'], -1) === ' ' ) { $trailingSpace = (strlen($tokens[($closeTag - 1)]['content']) - strlen(rtrim($tokens[($closeTag - 1)]['content']))); } if ($trailingSpace !== 1) { $error = 'Expected 1 space before closing PHP tag; %s found'; $data = [$trailingSpace]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpacingBeforeClose', $data); if ($fix === true) { if ($trailingSpace === 0) { $phpcsFile->fixer->addContentBefore($closeTag, ' '); } else if ($tokens[($closeTag - 1)]['code'] === T_COMMENT || isset(Tokens::$phpcsCommentTokens[$tokens[($closeTag - 1)]['code']]) === true ) { $phpcsFile->fixer->replaceToken(($closeTag - 1), rtrim($tokens[($closeTag - 1)]['content']).' '); } else { $phpcsFile->fixer->replaceToken(($closeTag - 1), ' '); } } } }//end validateInlineEmbeddedPhp() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/PHP/EvalSniff.php0000644000076500000240000000225213614652362024410 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\PHP; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class EvalSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_EVAL]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $error = 'Use of eval() is discouraged'; $phpcsFile->addWarning($error, $stackPtr, 'Discouraged'); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/PHP/GlobalKeywordSniff.php0000644000076500000240000000270213614652362026266 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\PHP; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class GlobalKeywordSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_GLOBAL]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $nextVar = $tokens[$phpcsFile->findNext([T_VARIABLE], $stackPtr)]; $varName = str_replace('$', '', $nextVar['content']); $error = 'Use of the "global" keyword is forbidden; use "$GLOBALS[\'%s\']" instead'; $data = [$varName]; $phpcsFile->addError($error, $stackPtr, 'NotAllowed', $data); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/PHP/HeredocSniff.php0000644000076500000240000000246213614652362025075 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\PHP; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class HeredocSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_START_HEREDOC, T_START_NOWDOC, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $error = 'Use of heredoc and nowdoc syntax ("<<<") is not allowed; use standard strings or inline HTML instead'; $phpcsFile->addError($error, $stackPtr, 'NotAllowed'); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/PHP/InnerFunctionsSniff.php0000644000076500000240000000350413614652362026466 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\PHP; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class InnerFunctionsSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_FUNCTION]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $function = $phpcsFile->getCondition($stackPtr, T_FUNCTION); if ($function === false) { // Not a nested function. return; } $class = $phpcsFile->getCondition($stackPtr, T_ANON_CLASS, false); if ($class !== false && $class > $function) { // Ignore methods in anon classes. return; } $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true); if ($tokens[$prev]['code'] === T_EQUAL) { // Ignore closures. return; } $error = 'The use of inner functions is forbidden'; $phpcsFile->addError($error, $stackPtr, 'NotAllowed'); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/PHP/LowercasePHPFunctionsSniff.php0000644000076500000240000001164313614652362027712 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\PHP; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class LowercasePHPFunctionsSniff implements Sniff { /** * String -> int hash map of all php built in function names * * @var array */ private $builtInFunctions; /** * Construct the LowercasePHPFunctionSniff */ public function __construct() { $allFunctions = get_defined_functions(); $this->builtInFunctions = array_flip($allFunctions['internal']); }//end __construct() /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_STRING]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $content = $tokens[$stackPtr]['content']; $contentLc = strtolower($content); if ($content === $contentLc) { return; } // Make sure it is an inbuilt PHP function. // PHP_CodeSniffer can possibly include user defined functions // through the use of vendor/autoload.php. if (isset($this->builtInFunctions[$contentLc]) === false) { return; } // Make sure this is a function call or a use statement. $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true); if ($next === false) { // Not a function call. return; } $ignore = Tokens::$emptyTokens; $ignore[] = T_BITWISE_AND; $prev = $phpcsFile->findPrevious($ignore, ($stackPtr - 1), null, true); $prevPrev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($prev - 1), null, true); if ($tokens[$next]['code'] !== T_OPEN_PARENTHESIS) { // Is this a use statement importing a PHP native function ? if ($tokens[$next]['code'] !== T_NS_SEPARATOR && $tokens[$prev]['code'] === T_STRING && $tokens[$prev]['content'] === 'function' && $prevPrev !== false && $tokens[$prevPrev]['code'] === T_USE ) { $error = 'Use statements for PHP native functions must be lowercase; expected "%s" but found "%s"'; $data = [ $contentLc, $content, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'UseStatementUppercase', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken($stackPtr, $contentLc); } } // No open parenthesis; not a "use function" statement nor a function call. return; }//end if if ($tokens[$prev]['code'] === T_FUNCTION) { // Function declaration, not a function call. return; } if ($tokens[$prev]['code'] === T_NS_SEPARATOR) { if ($prevPrev !== false && ($tokens[$prevPrev]['code'] === T_STRING || $tokens[$prevPrev]['code'] === T_NAMESPACE || $tokens[$prevPrev]['code'] === T_NEW) ) { // Namespaced class/function, not an inbuilt function. // Could potentially give false negatives for non-namespaced files // when namespace\functionName() is encountered. return; } } if ($tokens[$prev]['code'] === T_NEW) { // Object creation, not an inbuilt function. return; } if ($tokens[$prev]['code'] === T_OBJECT_OPERATOR) { // Not an inbuilt function. return; } if ($tokens[$prev]['code'] === T_DOUBLE_COLON) { // Not an inbuilt function. return; } $error = 'Calls to PHP native functions must be lowercase; expected "%s" but found "%s"'; $data = [ $contentLc, $content, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'CallUppercase', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken($stackPtr, $contentLc); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/PHP/NonExecutableCodeSniff.php0000644000076500000240000002364613614652362027062 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\PHP; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class NonExecutableCodeSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_BREAK, T_CONTINUE, T_RETURN, T_THROW, T_EXIT, T_GOTO, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // If this token is preceded with an "or", it only relates to one line // and should be ignored. For example: fopen() or die(). $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); if ($tokens[$prev]['code'] === T_LOGICAL_OR || $tokens[$prev]['code'] === T_BOOLEAN_OR) { return; } // Check if this token is actually part of a one-line IF or ELSE statement. for ($i = ($stackPtr - 1); $i > 0; $i--) { if ($tokens[$i]['code'] === T_CLOSE_PARENTHESIS) { $i = $tokens[$i]['parenthesis_opener']; continue; } else if (isset(Tokens::$emptyTokens[$tokens[$i]['code']]) === true) { continue; } break; } if ($tokens[$i]['code'] === T_IF || $tokens[$i]['code'] === T_ELSE || $tokens[$i]['code'] === T_ELSEIF ) { return; } if ($tokens[$stackPtr]['code'] === T_RETURN) { $next = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($tokens[$next]['code'] === T_SEMICOLON) { $next = $phpcsFile->findNext(T_WHITESPACE, ($next + 1), null, true); if ($tokens[$next]['code'] === T_CLOSE_CURLY_BRACKET) { // If this is the closing brace of a function // then this return statement doesn't return anything // and is not required anyway. $owner = $tokens[$next]['scope_condition']; if ($tokens[$owner]['code'] === T_FUNCTION) { $warning = 'Empty return statement not required here'; $phpcsFile->addWarning($warning, $stackPtr, 'ReturnNotRequired'); return; } } } } if (isset($tokens[$stackPtr]['scope_opener']) === true) { $owner = $tokens[$stackPtr]['scope_condition']; if ($tokens[$owner]['code'] === T_CASE || $tokens[$owner]['code'] === T_DEFAULT) { // This token closes the scope of a CASE or DEFAULT statement // so any code between this statement and the next CASE, DEFAULT or // end of SWITCH token will not be executable. $end = $phpcsFile->findEndOfStatement($stackPtr); $next = $phpcsFile->findNext( [ T_CASE, T_DEFAULT, T_CLOSE_CURLY_BRACKET, T_ENDSWITCH, ], ($end + 1) ); if ($next !== false) { $lastLine = $tokens[$end]['line']; for ($i = ($stackPtr + 1); $i < $next; $i++) { if (isset(Tokens::$emptyTokens[$tokens[$i]['code']]) === true) { continue; } $line = $tokens[$i]['line']; if ($line > $lastLine) { $type = substr($tokens[$stackPtr]['type'], 2); $warning = 'Code after the %s statement on line %s cannot be executed'; $data = [ $type, $tokens[$stackPtr]['line'], ]; $phpcsFile->addWarning($warning, $i, 'Unreachable', $data); $lastLine = $line; } } }//end if // That's all we have to check for these types of statements. return; }//end if }//end if // This token may be part of an inline condition. // If we find a closing parenthesis that belongs to a condition // we should ignore this token. $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); if (isset($tokens[$prev]['parenthesis_owner']) === true) { $owner = $tokens[$prev]['parenthesis_owner']; $ignore = [ T_IF => true, T_ELSE => true, T_ELSEIF => true, ]; if (isset($ignore[$tokens[$owner]['code']]) === true) { return; } } $ourConditions = array_keys($tokens[$stackPtr]['conditions']); if (empty($ourConditions) === false) { $condition = array_pop($ourConditions); if (isset($tokens[$condition]['scope_closer']) === false) { return; } // Special case for BREAK statements sitting directly inside SWITCH // statements. If we get to this point, we know the BREAK is not being // used to close a CASE statement, so it is most likely non-executable // code itself (as is the case when you put return; break; at the end of // a case). So we need to ignore this token. if ($tokens[$condition]['code'] === T_SWITCH && $tokens[$stackPtr]['code'] === T_BREAK ) { return; } $closer = $tokens[$condition]['scope_closer']; // If the closer for our condition is shared with other openers, // we will need to throw errors from this token to the next // shared opener (if there is one), not to the scope closer. $nextOpener = null; for ($i = ($stackPtr + 1); $i < $closer; $i++) { if (isset($tokens[$i]['scope_closer']) === true) { if ($tokens[$i]['scope_closer'] === $closer) { // We found an opener that shares the same // closing token as us. $nextOpener = $i; break; } } }//end for if ($nextOpener === null) { $end = $closer; } else { $end = ($nextOpener - 1); } } else { // This token is in the global scope. if ($tokens[$stackPtr]['code'] === T_BREAK) { return; } // Throw an error for all lines until the end of the file. $end = ($phpcsFile->numTokens - 1); }//end if // Find the semicolon that ends this statement, skipping // nested statements like FOR loops and closures. for ($start = ($stackPtr + 1); $start < $phpcsFile->numTokens; $start++) { if ($start === $end) { break; } if ($tokens[$start]['code'] === T_OPEN_PARENTHESIS) { $start = $tokens[$start]['parenthesis_closer']; continue; } if ($tokens[$start]['code'] === T_OPEN_CURLY_BRACKET) { $start = $tokens[$start]['bracket_closer']; continue; } if ($tokens[$start]['code'] === T_SEMICOLON) { break; } }//end for if (isset($tokens[$start]) === false) { return; } $lastLine = $tokens[$start]['line']; for ($i = ($start + 1); $i < $end; $i++) { if (isset(Tokens::$emptyTokens[$tokens[$i]['code']]) === true || isset(Tokens::$bracketTokens[$tokens[$i]['code']]) === true || $tokens[$i]['code'] === T_SEMICOLON ) { continue; } // Skip whole functions and classes/interfaces because they are not // technically executed code, but rather declarations that may be used. if (isset(Tokens::$ooScopeTokens[$tokens[$i]['code']]) === true || $tokens[$i]['code'] === T_FUNCTION || $tokens[$i]['code'] === T_CLOSURE ) { if (isset($tokens[$i]['scope_closer']) === false) { // Parse error/Live coding. return; } $i = $tokens[$i]['scope_closer']; continue; } $line = $tokens[$i]['line']; if ($line > $lastLine) { $type = substr($tokens[$stackPtr]['type'], 2); $warning = 'Code after the %s statement on line %s cannot be executed'; $data = [ $type, $tokens[$stackPtr]['line'], ]; $phpcsFile->addWarning($warning, $i, 'Unreachable', $data); $lastLine = $line; } }//end for }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Scope/MemberVarScopeSniff.php0000644000076500000240000000425513614652362027022 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Scope; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\AbstractVariableSniff; class MemberVarScopeSniff extends AbstractVariableSniff { /** * Processes the function tokens within the class. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param int $stackPtr The position where the token was found. * * @return void */ protected function processMemberVar(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $properties = $phpcsFile->getMemberProperties($stackPtr); if ($properties === [] || $properties['scope_specified'] !== false) { return; } $error = 'Scope modifier not specified for member variable "%s"'; $data = [$tokens[$stackPtr]['content']]; $phpcsFile->addError($error, $stackPtr, 'Missing', $data); }//end processMemberVar() /** * Processes normal variables. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param int $stackPtr The position where the token was found. * * @return void */ protected function processVariable(File $phpcsFile, $stackPtr) { /* We don't care about normal variables. */ }//end processVariable() /** * Processes variables in double quoted strings. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param int $stackPtr The position where the token was found. * * @return void */ protected function processVariableInString(File $phpcsFile, $stackPtr) { /* We don't care about normal variables. */ }//end processVariableInString() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Scope/MethodScopeSniff.php0000644000076500000240000000532713614652362026363 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Scope; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\AbstractScopeSniff; use PHP_CodeSniffer\Util\Tokens; class MethodScopeSniff extends AbstractScopeSniff { /** * Constructs a Squiz_Sniffs_Scope_MethodScopeSniff. */ public function __construct() { parent::__construct(Tokens::$ooScopeTokens, [T_FUNCTION]); }//end __construct() /** * Processes the function tokens within the class. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param int $stackPtr The position where the token was found. * @param int $currScope The current scope opener token. * * @return void */ protected function processTokenWithinScope(File $phpcsFile, $stackPtr, $currScope) { $tokens = $phpcsFile->getTokens(); // Determine if this is a function which needs to be examined. $conditions = $tokens[$stackPtr]['conditions']; end($conditions); $deepestScope = key($conditions); if ($deepestScope !== $currScope) { return; } $methodName = $phpcsFile->getDeclarationName($stackPtr); if ($methodName === null) { // Ignore closures. return; } $modifier = null; for ($i = ($stackPtr - 1); $i > 0; $i--) { if ($tokens[$i]['line'] < $tokens[$stackPtr]['line']) { break; } else if (isset(Tokens::$scopeModifiers[$tokens[$i]['code']]) === true) { $modifier = $i; break; } } if ($modifier === null) { $error = 'Visibility must be declared on method "%s"'; $data = [$methodName]; $phpcsFile->addError($error, $stackPtr, 'Missing', $data); } }//end processTokenWithinScope() /** * Processes a token that is found within the scope that this test is * listening to. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param int $stackPtr The position in the stack where this * token was found. * * @return void */ protected function processTokenOutsideScope(File $phpcsFile, $stackPtr) { }//end processTokenOutsideScope() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Scope/StaticThisUsageSniff.php0000644000076500000240000000665213614652362027217 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Scope; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\AbstractScopeSniff; use PHP_CodeSniffer\Util\Tokens; class StaticThisUsageSniff extends AbstractScopeSniff { /** * Constructs the test with the tokens it wishes to listen for. */ public function __construct() { parent::__construct([T_CLASS, T_TRAIT, T_ANON_CLASS], [T_FUNCTION]); }//end __construct() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * @param int $currScope A pointer to the start of the scope. * * @return void */ public function processTokenWithinScope(File $phpcsFile, $stackPtr, $currScope) { $tokens = $phpcsFile->getTokens(); // Determine if this is a function which needs to be examined. $conditions = $tokens[$stackPtr]['conditions']; end($conditions); $deepestScope = key($conditions); if ($deepestScope !== $currScope) { return; } // Ignore abstract functions. if (isset($tokens[$stackPtr]['scope_closer']) === false) { return; } $next = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true); if ($next === false || $tokens[$next]['code'] !== T_STRING) { // Not a function declaration, or incomplete. return; } $methodProps = $phpcsFile->getMethodProperties($stackPtr); if ($methodProps['is_static'] === false) { return; } $next = $stackPtr; $end = $tokens[$stackPtr]['scope_closer']; do { $next = $phpcsFile->findNext([T_VARIABLE, T_CLOSURE, T_ANON_CLASS], ($next + 1), $end); if ($next === false) { continue; } else if ($tokens[$next]['code'] === T_CLOSURE || $tokens[$next]['code'] === T_ANON_CLASS ) { $next = $tokens[$next]['scope_closer']; continue; } else if (strtolower($tokens[$next]['content']) !== '$this') { continue; } $error = 'Usage of "$this" in static methods will cause runtime errors'; $phpcsFile->addError($error, $next, 'Found'); } while ($next !== false); }//end processTokenWithinScope() /** * Processes a token that is found within the scope that this test is * listening to. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param int $stackPtr The position in the stack where this * token was found. * * @return void */ protected function processTokenOutsideScope(File $phpcsFile, $stackPtr) { }//end processTokenOutsideScope() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Strings/ConcatenationSpacingSniff.php0000644000076500000240000001261313614652362030617 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Strings; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class ConcatenationSpacingSniff implements Sniff { /** * The number of spaces before and after a string concat. * * @var integer */ public $spacing = 0; /** * Allow newlines instead of spaces. * * @var boolean */ public $ignoreNewlines = false; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_STRING_CONCAT]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $ignoreBefore = false; $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); if ($tokens[$prev]['code'] === T_END_HEREDOC || $tokens[$prev]['code'] === T_END_NOWDOC) { // Spacing before must be preserved due to the here/nowdoc closing tag. $ignoreBefore = true; } $this->spacing = (int) $this->spacing; if ($ignoreBefore === false) { if ($tokens[($stackPtr - 1)]['code'] !== T_WHITESPACE) { $before = 0; } else { if ($tokens[($stackPtr - 2)]['line'] !== $tokens[$stackPtr]['line']) { $before = 'newline'; } else { $before = $tokens[($stackPtr - 1)]['length']; } } $phpcsFile->recordMetric($stackPtr, 'Spacing before string concat', $before); } if ($tokens[($stackPtr + 1)]['code'] !== T_WHITESPACE) { $after = 0; } else { if ($tokens[($stackPtr + 2)]['line'] !== $tokens[$stackPtr]['line']) { $after = 'newline'; } else { $after = $tokens[($stackPtr + 1)]['length']; } } $phpcsFile->recordMetric($stackPtr, 'Spacing after string concat', $after); if (($ignoreBefore === true || $before === $this->spacing || ($before === 'newline' && $this->ignoreNewlines === true)) && ($after === $this->spacing || ($after === 'newline' && $this->ignoreNewlines === true)) ) { return; } if ($this->spacing === 0) { $message = 'Concat operator must not be surrounded by spaces'; $data = []; } else { if ($this->spacing > 1) { $message = 'Concat operator must be surrounded by %s spaces'; } else { $message = 'Concat operator must be surrounded by a single space'; } $data = [$this->spacing]; } $fix = $phpcsFile->addFixableError($message, $stackPtr, 'PaddingFound', $data); if ($fix === true) { $padding = str_repeat(' ', $this->spacing); if ($ignoreBefore === false && ($before !== 'newline' || $this->ignoreNewlines === false)) { if ($tokens[($stackPtr - 1)]['code'] === T_WHITESPACE) { $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->replaceToken(($stackPtr - 1), $padding); if ($this->spacing === 0 && ($tokens[($stackPtr - 2)]['code'] === T_LNUMBER || $tokens[($stackPtr - 2)]['code'] === T_DNUMBER) ) { $phpcsFile->fixer->replaceToken(($stackPtr - 2), '('.$tokens[($stackPtr - 2)]['content'].')'); } $phpcsFile->fixer->endChangeset(); } else if ($this->spacing > 0) { $phpcsFile->fixer->addContent(($stackPtr - 1), $padding); } } if ($after !== 'newline' || $this->ignoreNewlines === false) { if ($tokens[($stackPtr + 1)]['code'] === T_WHITESPACE) { $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->replaceToken(($stackPtr + 1), $padding); if ($this->spacing === 0 && ($tokens[($stackPtr + 2)]['code'] === T_LNUMBER || $tokens[($stackPtr + 2)]['code'] === T_DNUMBER) ) { $phpcsFile->fixer->replaceToken(($stackPtr + 2), '('.$tokens[($stackPtr + 2)]['content'].')'); } $phpcsFile->fixer->endChangeset(); } else if ($this->spacing > 0) { $phpcsFile->fixer->addContent($stackPtr, $padding); } } }//end if }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Strings/DoubleQuoteUsageSniff.php0000644000076500000240000001051513614652362027741 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Strings; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class DoubleQuoteUsageSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_CONSTANT_ENCAPSED_STRING, T_DOUBLE_QUOTED_STRING, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // If tabs are being converted to spaces by the tokeniser, the // original content should be used instead of the converted content. if (isset($tokens[$stackPtr]['orig_content']) === true) { $workingString = $tokens[$stackPtr]['orig_content']; } else { $workingString = $tokens[$stackPtr]['content']; } $lastStringToken = $stackPtr; $i = ($stackPtr + 1); if (isset($tokens[$i]) === true) { while ($i < $phpcsFile->numTokens && $tokens[$i]['code'] === $tokens[$stackPtr]['code'] ) { if (isset($tokens[$i]['orig_content']) === true) { $workingString .= $tokens[$i]['orig_content']; } else { $workingString .= $tokens[$i]['content']; } $lastStringToken = $i; $i++; } } $skipTo = ($lastStringToken + 1); // Check if it's a double quoted string. if ($workingString[0] !== '"' || substr($workingString, -1) !== '"') { return $skipTo; } // The use of variables in double quoted strings is not allowed. if ($tokens[$stackPtr]['code'] === T_DOUBLE_QUOTED_STRING) { $stringTokens = token_get_all('addError($error, $stackPtr, 'ContainsVar', $data); } } return $skipTo; }//end if $allowedChars = [ '\0', '\1', '\2', '\3', '\4', '\5', '\6', '\7', '\n', '\r', '\f', '\t', '\v', '\x', '\b', '\e', '\u', '\'', ]; foreach ($allowedChars as $testChar) { if (strpos($workingString, $testChar) !== false) { return $skipTo; } } $error = 'String %s does not require double quotes; use single quotes instead'; $data = [str_replace(["\r", "\n"], ['\r', '\n'], $workingString)]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NotRequired', $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $innerContent = substr($workingString, 1, -1); $innerContent = str_replace('\"', '"', $innerContent); $innerContent = str_replace('\\$', '$', $innerContent); $phpcsFile->fixer->replaceToken($stackPtr, "'$innerContent'"); while ($lastStringToken !== $stackPtr) { $phpcsFile->fixer->replaceToken($lastStringToken, ''); $lastStringToken--; } $phpcsFile->fixer->endChangeset(); } return $skipTo; }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/Strings/EchoedStringsSniff.php0000644000076500000240000000612013614652362027262 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\Strings; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class EchoedStringsSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_ECHO]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $firstContent = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); // If the first non-whitespace token is not an opening parenthesis, then we are not concerned. if ($tokens[$firstContent]['code'] !== T_OPEN_PARENTHESIS) { $phpcsFile->recordMetric($stackPtr, 'Brackets around echoed strings', 'no'); return; } $end = $phpcsFile->findNext([T_SEMICOLON, T_CLOSE_TAG], $stackPtr, null, false); // If the token before the semi-colon is not a closing parenthesis, then we are not concerned. $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($end - 1), null, true); if ($tokens[$prev]['code'] !== T_CLOSE_PARENTHESIS) { $phpcsFile->recordMetric($stackPtr, 'Brackets around echoed strings', 'no'); return; } // If the parenthesis don't match, then we are not concerned. if ($tokens[$firstContent]['parenthesis_closer'] !== $prev) { $phpcsFile->recordMetric($stackPtr, 'Brackets around echoed strings', 'no'); return; } $phpcsFile->recordMetric($stackPtr, 'Brackets around echoed strings', 'yes'); if (($phpcsFile->findNext(Tokens::$operators, $stackPtr, $end, false)) === false) { // There are no arithmetic operators in this. $error = 'Echoed strings should not be bracketed'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'HasBracket'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->replaceToken($firstContent, ''); if ($tokens[($firstContent - 1)]['code'] !== T_WHITESPACE) { $phpcsFile->fixer->addContent(($firstContent - 1), ' '); } $phpcsFile->fixer->replaceToken($prev, ''); $phpcsFile->fixer->endChangeset(); } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/WhiteSpace/CastSpacingSniff.php0000644000076500000240000000341613614652362027330 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\WhiteSpace; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class CastSpacingSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return Tokens::$castTokens; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $content = $tokens[$stackPtr]['content']; $expected = str_replace(' ', '', $content); $expected = str_replace("\t", '', $expected); if ($content !== $expected) { $error = 'Cast statements must not contain whitespace; expected "%s" but found "%s"'; $data = [ $expected, $content, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'ContainsWhiteSpace', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken($stackPtr, $expected); } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/WhiteSpace/ControlStructureSpacingSniff.php0000644000076500000240000003151613614652362032001 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\WhiteSpace; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class ControlStructureSpacingSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_IF, T_WHILE, T_FOREACH, T_FOR, T_SWITCH, T_DO, T_ELSE, T_ELSEIF, T_TRY, T_CATCH, T_FINALLY, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['parenthesis_opener']) === true && isset($tokens[$stackPtr]['parenthesis_closer']) === true ) { $parenOpener = $tokens[$stackPtr]['parenthesis_opener']; $parenCloser = $tokens[$stackPtr]['parenthesis_closer']; if ($tokens[($parenOpener + 1)]['code'] === T_WHITESPACE) { $gap = $tokens[($parenOpener + 1)]['length']; if ($gap === 0) { $phpcsFile->recordMetric($stackPtr, 'Spaces after control structure open parenthesis', 'newline'); $gap = 'newline'; } else { $phpcsFile->recordMetric($stackPtr, 'Spaces after control structure open parenthesis', $gap); } $error = 'Expected 0 spaces after opening bracket; %s found'; $data = [$gap]; $fix = $phpcsFile->addFixableError($error, ($parenOpener + 1), 'SpacingAfterOpenBrace', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($parenOpener + 1), ''); } } else { $phpcsFile->recordMetric($stackPtr, 'Spaces after control structure open parenthesis', 0); } if ($tokens[$parenOpener]['line'] === $tokens[$parenCloser]['line'] && $tokens[($parenCloser - 1)]['code'] === T_WHITESPACE ) { $gap = $tokens[($parenCloser - 1)]['length']; $error = 'Expected 0 spaces before closing bracket; %s found'; $data = [$gap]; $fix = $phpcsFile->addFixableError($error, ($parenCloser - 1), 'SpaceBeforeCloseBrace', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($parenCloser - 1), ''); } if ($gap === 0) { $phpcsFile->recordMetric($stackPtr, 'Spaces before control structure close parenthesis', 'newline'); } else { $phpcsFile->recordMetric($stackPtr, 'Spaces before control structure close parenthesis', $gap); } } else { $phpcsFile->recordMetric($stackPtr, 'Spaces before control structure close parenthesis', 0); } }//end if if (isset($tokens[$stackPtr]['scope_closer']) === false) { return; } $scopeOpener = $tokens[$stackPtr]['scope_opener']; $scopeCloser = $tokens[$stackPtr]['scope_closer']; for ($firstContent = ($scopeOpener + 1); $firstContent < $phpcsFile->numTokens; $firstContent++) { $code = $tokens[$firstContent]['code']; if ($code === T_WHITESPACE || ($code === T_INLINE_HTML && trim($tokens[$firstContent]['content']) === '') ) { continue; } // Skip all empty tokens on the same line as the opener. if ($tokens[$firstContent]['line'] === $tokens[$scopeOpener]['line'] && (isset(Tokens::$emptyTokens[$code]) === true || $code === T_CLOSE_TAG) ) { continue; } break; } // We ignore spacing for some structures that tend to have their own rules. $ignore = [ T_FUNCTION => true, T_CLASS => true, T_INTERFACE => true, T_TRAIT => true, T_DOC_COMMENT_OPEN_TAG => true, ]; if (isset($ignore[$tokens[$firstContent]['code']]) === false && $tokens[$firstContent]['line'] >= ($tokens[$scopeOpener]['line'] + 2) ) { $gap = ($tokens[$firstContent]['line'] - $tokens[$scopeOpener]['line'] - 1); $phpcsFile->recordMetric($stackPtr, 'Blank lines at start of control structure', $gap); $error = 'Blank line found at start of control structure'; $fix = $phpcsFile->addFixableError($error, $scopeOpener, 'SpacingAfterOpen'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $i = ($scopeOpener + 1); while ($tokens[$i]['line'] !== $tokens[$firstContent]['line']) { // Start removing content from the line after the opener. if ($tokens[$i]['line'] !== $tokens[$scopeOpener]['line']) { $phpcsFile->fixer->replaceToken($i, ''); } $i++; } $phpcsFile->fixer->endChangeset(); } } else { $phpcsFile->recordMetric($stackPtr, 'Blank lines at start of control structure', 0); }//end if if ($firstContent !== $scopeCloser) { $lastContent = $phpcsFile->findPrevious( T_WHITESPACE, ($scopeCloser - 1), null, true ); $lastNonEmptyContent = $phpcsFile->findPrevious( Tokens::$emptyTokens, ($scopeCloser - 1), null, true ); $checkToken = $lastContent; if (isset($tokens[$lastNonEmptyContent]['scope_condition']) === true) { $checkToken = $tokens[$lastNonEmptyContent]['scope_condition']; } if (isset($ignore[$tokens[$checkToken]['code']]) === false && $tokens[$lastContent]['line'] <= ($tokens[$scopeCloser]['line'] - 2) ) { $errorToken = $scopeCloser; for ($i = ($scopeCloser - 1); $i > $lastContent; $i--) { if ($tokens[$i]['line'] < $tokens[$scopeCloser]['line']) { $errorToken = $i; break; } } $gap = ($tokens[$scopeCloser]['line'] - $tokens[$lastContent]['line'] - 1); $phpcsFile->recordMetric($stackPtr, 'Blank lines at end of control structure', $gap); $error = 'Blank line found at end of control structure'; $fix = $phpcsFile->addFixableError($error, $errorToken, 'SpacingBeforeClose'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($scopeCloser - 1); $i > $lastContent; $i--) { if ($tokens[$i]['line'] === $tokens[$scopeCloser]['line']) { continue; } if ($tokens[$i]['line'] === $tokens[$lastContent]['line']) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } } else { $phpcsFile->recordMetric($stackPtr, 'Blank lines at end of control structure', 0); }//end if }//end if $trailingContent = $phpcsFile->findNext( T_WHITESPACE, ($scopeCloser + 1), null, true ); if ($tokens[$trailingContent]['code'] === T_COMMENT || isset(Tokens::$phpcsCommentTokens[$tokens[$trailingContent]['code']]) === true ) { // Special exception for code where the comment about // an ELSE or ELSEIF is written between the control structures. $nextCode = $phpcsFile->findNext( Tokens::$emptyTokens, ($scopeCloser + 1), null, true ); if ($tokens[$nextCode]['code'] === T_ELSE || $tokens[$nextCode]['code'] === T_ELSEIF || $tokens[$trailingContent]['line'] === $tokens[$scopeCloser]['line'] ) { $trailingContent = $nextCode; } }//end if if ($tokens[$trailingContent]['code'] === T_ELSE) { if ($tokens[$stackPtr]['code'] === T_IF) { // IF with ELSE. return; } } if ($tokens[$trailingContent]['code'] === T_WHILE && $tokens[$stackPtr]['code'] === T_DO ) { // DO with WHILE. return; } if ($tokens[$trailingContent]['code'] === T_CLOSE_TAG) { // At the end of the script or embedded code. return; } if (isset($tokens[$trailingContent]['scope_condition']) === true && $tokens[$trailingContent]['scope_condition'] !== $trailingContent && isset($tokens[$trailingContent]['scope_opener']) === true && $tokens[$trailingContent]['scope_opener'] !== $trailingContent ) { // Another control structure's closing brace. $owner = $tokens[$trailingContent]['scope_condition']; if ($tokens[$owner]['code'] === T_FUNCTION) { // The next content is the closing brace of a function // so normal function rules apply and we can ignore it. return; } if ($tokens[$owner]['code'] === T_CLOSURE && ($phpcsFile->hasCondition($stackPtr, [T_FUNCTION, T_CLOSURE]) === true || isset($tokens[$stackPtr]['nested_parenthesis']) === true) ) { return; } if ($tokens[$trailingContent]['line'] !== ($tokens[$scopeCloser]['line'] + 1)) { $error = 'Blank line found after control structure'; $fix = $phpcsFile->addFixableError($error, $scopeCloser, 'LineAfterClose'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $i = ($scopeCloser + 1); while ($tokens[$i]['line'] !== $tokens[$trailingContent]['line']) { $phpcsFile->fixer->replaceToken($i, ''); $i++; } $phpcsFile->fixer->addNewline($scopeCloser); $phpcsFile->fixer->endChangeset(); } } } else if ($tokens[$trailingContent]['code'] !== T_ELSE && $tokens[$trailingContent]['code'] !== T_ELSEIF && $tokens[$trailingContent]['code'] !== T_CATCH && $tokens[$trailingContent]['code'] !== T_FINALLY && $tokens[$trailingContent]['line'] === ($tokens[$scopeCloser]['line'] + 1) ) { $error = 'No blank line found after control structure'; $fix = $phpcsFile->addFixableError($error, $scopeCloser, 'NoLineAfterClose'); if ($fix === true) { $trailingContent = $phpcsFile->findNext( T_WHITESPACE, ($scopeCloser + 1), null, true ); if (($tokens[$trailingContent]['code'] === T_COMMENT || isset(Tokens::$phpcsCommentTokens[$tokens[$trailingContent]['code']]) === true) && $tokens[$trailingContent]['line'] === $tokens[$scopeCloser]['line'] ) { $phpcsFile->fixer->addNewline($trailingContent); } else { $phpcsFile->fixer->addNewline($scopeCloser); } } }//end if }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/WhiteSpace/FunctionClosingBraceSpaceSniff.php0000644000076500000240000001352613614652362032151 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\WhiteSpace; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class FunctionClosingBraceSpaceSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_FUNCTION, T_CLOSURE, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['scope_closer']) === false) { // Probably an interface method. return; } $closeBrace = $tokens[$stackPtr]['scope_closer']; $prevContent = $phpcsFile->findPrevious(T_WHITESPACE, ($closeBrace - 1), null, true); // Special case for empty JS functions. if ($phpcsFile->tokenizerType === 'JS' && $prevContent === $tokens[$stackPtr]['scope_opener']) { // In this case, the opening and closing brace must be // right next to each other. if ($tokens[$stackPtr]['scope_closer'] !== ($tokens[$stackPtr]['scope_opener'] + 1)) { $error = 'The opening and closing braces of empty functions must be directly next to each other; e.g., function () {}'; $fix = $phpcsFile->addFixableError($error, $closeBrace, 'SpacingBetween'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($tokens[$stackPtr]['scope_opener'] + 1); $i < $closeBrace; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } } return; } $nestedFunction = false; if ($phpcsFile->hasCondition($stackPtr, [T_FUNCTION, T_CLOSURE]) === true || isset($tokens[$stackPtr]['nested_parenthesis']) === true ) { $nestedFunction = true; } $braceLine = $tokens[$closeBrace]['line']; $prevLine = $tokens[$prevContent]['line']; $found = ($braceLine - $prevLine - 1); if ($nestedFunction === true) { if ($found < 0) { $error = 'Closing brace of nested function must be on a new line'; $fix = $phpcsFile->addFixableError($error, $closeBrace, 'ContentBeforeClose'); if ($fix === true) { $phpcsFile->fixer->addNewlineBefore($closeBrace); } } else if ($found > 0) { $error = 'Expected 0 blank lines before closing brace of nested function; %s found'; $data = [$found]; $fix = $phpcsFile->addFixableError($error, $closeBrace, 'SpacingBeforeNestedClose', $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $changeMade = false; for ($i = ($prevContent + 1); $i < $closeBrace; $i++) { // Try and maintain indentation. if ($tokens[$i]['line'] === ($braceLine - 1)) { break; } $phpcsFile->fixer->replaceToken($i, ''); $changeMade = true; } // Special case for when the last content contains the newline // token as well, like with a comment. if ($changeMade === false) { $phpcsFile->fixer->replaceToken(($prevContent + 1), ''); } $phpcsFile->fixer->endChangeset(); }//end if }//end if } else { if ($found !== 1) { if ($found < 0) { $found = 0; } $error = 'Expected 1 blank line before closing function brace; %s found'; $data = [$found]; $fix = $phpcsFile->addFixableError($error, $closeBrace, 'SpacingBeforeClose', $data); if ($fix === true) { if ($found > 1) { $phpcsFile->fixer->beginChangeset(); for ($i = ($prevContent + 1); $i < ($closeBrace - 1); $i++) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->replaceToken($i, $phpcsFile->eolChar); $phpcsFile->fixer->endChangeset(); } else { // Try and maintain indentation. if ($tokens[($closeBrace - 1)]['code'] === T_WHITESPACE) { $phpcsFile->fixer->addNewlineBefore($closeBrace - 1); } else { $phpcsFile->fixer->addNewlineBefore($closeBrace); } } } }//end if }//end if }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/WhiteSpace/FunctionOpeningBraceSpaceSniff.php0000644000076500000240000000546613614652362032156 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\WhiteSpace; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class FunctionOpeningBraceSpaceSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_FUNCTION, T_CLOSURE, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[$stackPtr]['scope_opener']) === false) { // Probably an interface or abstract method. return; } $openBrace = $tokens[$stackPtr]['scope_opener']; $nextContent = $phpcsFile->findNext(T_WHITESPACE, ($openBrace + 1), null, true); if ($nextContent === $tokens[$stackPtr]['scope_closer']) { // The next bit of content is the closing brace, so this // is an empty function and should have a blank line // between the opening and closing braces. return; } $braceLine = $tokens[$openBrace]['line']; $nextLine = $tokens[$nextContent]['line']; $found = ($nextLine - $braceLine - 1); if ($found > 0) { $error = 'Expected 0 blank lines after opening function brace; %s found'; $data = [$found]; $fix = $phpcsFile->addFixableError($error, $openBrace, 'SpacingAfter', $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($openBrace + 1); $i < $nextContent; $i++) { if ($tokens[$i]['line'] === $nextLine) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->addNewline($openBrace); $phpcsFile->fixer->endChangeset(); } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/WhiteSpace/FunctionSpacingSniff.php0000644000076500000240000003104013614652362030215 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\WhiteSpace; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class FunctionSpacingSniff implements Sniff { /** * The number of blank lines between functions. * * @var integer */ public $spacing = 2; /** * The number of blank lines before the first function in a class. * * @var integer */ public $spacingBeforeFirst = 2; /** * The number of blank lines after the last function in a class. * * @var integer */ public $spacingAfterLast = 2; /** * Original properties as set in a custom ruleset (if any). * * @var array|null */ private $rulesetProperties = null; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_FUNCTION]; }//end register() /** * Processes this sniff when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $previousNonEmpty = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); if ($previousNonEmpty !== false && $tokens[$previousNonEmpty]['code'] === T_OPEN_TAG && $tokens[$previousNonEmpty]['line'] !== 1 ) { // Ignore functions at the start of an embedded PHP block. return; } // If the ruleset has only overridden the spacing property, use // that value for all spacing rules. if ($this->rulesetProperties === null) { $this->rulesetProperties = []; if (isset($phpcsFile->ruleset->ruleset['Squiz.WhiteSpace.FunctionSpacing']) === true && isset($phpcsFile->ruleset->ruleset['Squiz.WhiteSpace.FunctionSpacing']['properties']) === true ) { $this->rulesetProperties = $phpcsFile->ruleset->ruleset['Squiz.WhiteSpace.FunctionSpacing']['properties']; if (isset($this->rulesetProperties['spacing']) === true) { if (isset($this->rulesetProperties['spacingBeforeFirst']) === false) { $this->spacingBeforeFirst = $this->spacing; } if (isset($this->rulesetProperties['spacingAfterLast']) === false) { $this->spacingAfterLast = $this->spacing; } } } } $this->spacing = (int) $this->spacing; $this->spacingBeforeFirst = (int) $this->spacingBeforeFirst; $this->spacingAfterLast = (int) $this->spacingAfterLast; if (isset($tokens[$stackPtr]['scope_closer']) === false) { // Must be an interface method, so the closer is the semicolon. $closer = $phpcsFile->findNext(T_SEMICOLON, $stackPtr); } else { $closer = $tokens[$stackPtr]['scope_closer']; } $isFirst = false; $isLast = false; $ignore = ([T_WHITESPACE => T_WHITESPACE] + Tokens::$methodPrefixes); $prev = $phpcsFile->findPrevious($ignore, ($stackPtr - 1), null, true); if ($tokens[$prev]['code'] === T_DOC_COMMENT_CLOSE_TAG) { // Skip past function docblocks. $prev = $phpcsFile->findPrevious($ignore, ($tokens[$prev]['comment_opener'] - 1), null, true); } if ($tokens[$prev]['code'] === T_OPEN_CURLY_BRACKET) { $isFirst = true; } $next = $phpcsFile->findNext($ignore, ($closer + 1), null, true); if (isset(Tokens::$emptyTokens[$tokens[$next]['code']]) === true && $tokens[$next]['line'] === $tokens[$closer]['line'] ) { // Skip past "end" comments. $next = $phpcsFile->findNext($ignore, ($next + 1), null, true); } if ($tokens[$next]['code'] === T_CLOSE_CURLY_BRACKET) { $isLast = true; } /* Check the number of blank lines after the function. */ // Allow for comments on the same line as the closer. for ($nextLineToken = ($closer + 1); $nextLineToken < $phpcsFile->numTokens; $nextLineToken++) { if ($tokens[$nextLineToken]['line'] !== $tokens[$closer]['line']) { break; } } $requiredSpacing = $this->spacing; $errorCode = 'After'; if ($isLast === true) { $requiredSpacing = $this->spacingAfterLast; $errorCode = 'AfterLast'; } $foundLines = 0; if ($nextLineToken === ($phpcsFile->numTokens - 1)) { // We are at the end of the file. // Don't check spacing after the function because this // should be done by an EOF sniff. $foundLines = $requiredSpacing; } else { $nextContent = $phpcsFile->findNext(T_WHITESPACE, $nextLineToken, null, true); if ($nextContent === false) { // We are at the end of the file. // Don't check spacing after the function because this // should be done by an EOF sniff. $foundLines = $requiredSpacing; } else { $foundLines = ($tokens[$nextContent]['line'] - $tokens[$nextLineToken]['line']); } } if ($isLast === true) { $phpcsFile->recordMetric($stackPtr, 'Function spacing after last', $foundLines); } else { $phpcsFile->recordMetric($stackPtr, 'Function spacing after', $foundLines); } if ($foundLines !== $requiredSpacing) { $error = 'Expected %s blank line'; if ($requiredSpacing !== 1) { $error .= 's'; } $error .= ' after function; %s found'; $data = [ $requiredSpacing, $foundLines, ]; $fix = $phpcsFile->addFixableError($error, $closer, $errorCode, $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = $nextLineToken; $i <= $nextContent; $i++) { if ($tokens[$i]['line'] === $tokens[$nextContent]['line']) { $phpcsFile->fixer->addContentBefore($i, str_repeat($phpcsFile->eolChar, $requiredSpacing)); break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); }//end if }//end if /* Check the number of blank lines before the function. */ $prevLineToken = null; for ($i = $stackPtr; $i >= 0; $i--) { if ($tokens[$i]['line'] === $tokens[$stackPtr]['line']) { continue; } $prevLineToken = $i; break; } if ($prevLineToken === null) { // Never found the previous line, which means // there are 0 blank lines before the function. $foundLines = 0; $prevContent = 0; $prevLineToken = 0; } else { $currentLine = $tokens[$stackPtr]['line']; $prevContent = $phpcsFile->findPrevious(T_WHITESPACE, $prevLineToken, null, true); if ($tokens[$prevContent]['code'] === T_COMMENT || isset(Tokens::$phpcsCommentTokens[$tokens[$prevContent]['code']]) === true ) { // Ignore comments as they can have different spacing rules, and this // isn't a proper function comment anyway. return; } if ($tokens[$prevContent]['code'] === T_DOC_COMMENT_CLOSE_TAG && $tokens[$prevContent]['line'] === ($currentLine - 1) ) { // Account for function comments. $prevContent = $phpcsFile->findPrevious(T_WHITESPACE, ($tokens[$prevContent]['comment_opener'] - 1), null, true); } $prevLineToken = $prevContent; // Before we throw an error, check that we are not throwing an error // for another function. We don't want to error for no blank lines after // the previous function and no blank lines before this one as well. $prevLine = ($tokens[$prevContent]['line'] - 1); $i = ($stackPtr - 1); $foundLines = 0; $stopAt = 0; if (isset($tokens[$stackPtr]['conditions']) === true) { $conditions = $tokens[$stackPtr]['conditions']; $conditions = array_keys($conditions); $stopAt = array_pop($conditions); } while ($currentLine !== $prevLine && $currentLine > 1 && $i > $stopAt) { if ($tokens[$i]['code'] === T_FUNCTION) { // Found another interface or abstract function. return; } if ($tokens[$i]['code'] === T_CLOSE_CURLY_BRACKET && $tokens[$tokens[$i]['scope_condition']]['code'] === T_FUNCTION ) { // Found a previous function. return; } $currentLine = $tokens[$i]['line']; if ($currentLine === $prevLine) { break; } if ($tokens[($i - 1)]['line'] < $currentLine && $tokens[($i + 1)]['line'] > $currentLine) { // This token is on a line by itself. If it is whitespace, the line is empty. if ($tokens[$i]['code'] === T_WHITESPACE) { $foundLines++; } } $i--; }//end while }//end if $requiredSpacing = $this->spacing; $errorCode = 'Before'; if ($isFirst === true) { $requiredSpacing = $this->spacingBeforeFirst; $errorCode = 'BeforeFirst'; $phpcsFile->recordMetric($stackPtr, 'Function spacing before first', $foundLines); } else { $phpcsFile->recordMetric($stackPtr, 'Function spacing before', $foundLines); } if ($foundLines !== $requiredSpacing) { $error = 'Expected %s blank line'; if ($requiredSpacing !== 1) { $error .= 's'; } $error .= ' before function; %s found'; $data = [ $requiredSpacing, $foundLines, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, $errorCode, $data); if ($fix === true) { $nextSpace = $phpcsFile->findNext(T_WHITESPACE, ($prevContent + 1), $stackPtr); if ($nextSpace === false) { $nextSpace = ($stackPtr - 1); } if ($foundLines < $requiredSpacing) { $padding = str_repeat($phpcsFile->eolChar, ($requiredSpacing - $foundLines)); $phpcsFile->fixer->addContent($prevLineToken, $padding); } else { $nextContent = $phpcsFile->findNext(T_WHITESPACE, ($nextSpace + 1), null, true); $phpcsFile->fixer->beginChangeset(); for ($i = $nextSpace; $i < $nextContent; $i++) { if ($tokens[$i]['line'] === $tokens[$prevContent]['line']) { continue; } if ($tokens[$i]['line'] === $tokens[$nextContent]['line']) { $phpcsFile->fixer->addContentBefore($i, str_repeat($phpcsFile->eolChar, $requiredSpacing)); break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); }//end if }//end if }//end if }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/WhiteSpace/LanguageConstructSpacingSniff.php0000644000076500000240000000553313614652362032070 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\WhiteSpace; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util; class LanguageConstructSpacingSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_ECHO, T_PRINT, T_RETURN, T_INCLUDE, T_INCLUDE_ONCE, T_REQUIRE, T_REQUIRE_ONCE, T_NEW, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[($stackPtr + 1)]) === false) { // Skip if there is no next token. return; } if ($tokens[($stackPtr + 1)]['code'] === T_SEMICOLON) { // No content for this language construct. return; } if ($tokens[($stackPtr + 1)]['code'] === T_WHITESPACE) { $content = $tokens[($stackPtr + 1)]['content']; if ($content !== ' ') { $error = 'Language constructs must be followed by a single space; expected 1 space but found "%s"'; $data = [Util\Common::prepareForOutput($content)]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'IncorrectSingle', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($stackPtr + 1), ' '); } } } else if ($tokens[($stackPtr + 1)]['code'] !== T_OPEN_PARENTHESIS) { $error = 'Language constructs must be followed by a single space; expected "%s" but found "%s"'; $data = [ $tokens[$stackPtr]['content'].' '.$tokens[($stackPtr + 1)]['content'], $tokens[$stackPtr]['content'].$tokens[($stackPtr + 1)]['content'], ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Incorrect', $data); if ($fix === true) { $phpcsFile->fixer->addContent($stackPtr, ' '); } }//end if }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/WhiteSpace/LogicalOperatorSpacingSniff.php0000644000076500000240000000673113614652362031527 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\WhiteSpace; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class LogicalOperatorSpacingSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return Tokens::$booleanOperators; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being checked. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Check there is one space before the operator. if ($tokens[($stackPtr - 1)]['code'] !== T_WHITESPACE) { $error = 'Expected 1 space before logical operator; 0 found'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NoSpaceBefore'); if ($fix === true) { $phpcsFile->fixer->addContentBefore($stackPtr, ' '); } } else { $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true); if ($tokens[$stackPtr]['line'] === $tokens[$prev]['line'] && $tokens[($stackPtr - 1)]['length'] !== 1 ) { $found = $tokens[($stackPtr - 1)]['length']; $error = 'Expected 1 space before logical operator; %s found'; $data = [$found]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'TooMuchSpaceBefore', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($stackPtr - 1), ' '); } } } // Check there is one space after the operator. if ($tokens[($stackPtr + 1)]['code'] !== T_WHITESPACE) { $error = 'Expected 1 space after logical operator; 0 found'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NoSpaceAfter'); if ($fix === true) { $phpcsFile->fixer->addContent($stackPtr, ' '); } } else { $next = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($tokens[$stackPtr]['line'] === $tokens[$next]['line'] && $tokens[($stackPtr + 1)]['length'] !== 1 ) { $found = $tokens[($stackPtr + 1)]['length']; $error = 'Expected 1 space after logical operator; %s found'; $data = [$found]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'TooMuchSpaceAfter', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($stackPtr + 1), ' '); } } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/WhiteSpace/MemberVarSpacingSniff.php0000644000076500000240000001710313614652362030314 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\WhiteSpace; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\AbstractVariableSniff; use PHP_CodeSniffer\Util\Tokens; class MemberVarSpacingSniff extends AbstractVariableSniff { /** * The number of blank lines between member vars. * * @var integer */ public $spacing = 1; /** * The number of blank lines before the first member var. * * @var integer */ public $spacingBeforeFirst = 1; /** * Processes the function tokens within the class. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param int $stackPtr The position where the token was found. * * @return void|int Optionally returns a stack pointer. The sniff will not be * called again on the current file until the returned stack * pointer is reached. */ protected function processMemberVar(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $validPrefixes = Tokens::$methodPrefixes; $validPrefixes[] = T_VAR; $startOfStatement = $phpcsFile->findPrevious($validPrefixes, ($stackPtr - 1), null, false, null, true); if ($startOfStatement === false) { return; } $endOfStatement = $phpcsFile->findNext(T_SEMICOLON, ($stackPtr + 1), null, false, null, true); $ignore = $validPrefixes; $ignore[] = T_WHITESPACE; $start = $startOfStatement; $prev = $phpcsFile->findPrevious($ignore, ($startOfStatement - 1), null, true); if (isset(Tokens::$commentTokens[$tokens[$prev]['code']]) === true) { // Assume the comment belongs to the member var if it is on a line by itself. $prevContent = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($prev - 1), null, true); if ($tokens[$prevContent]['line'] !== $tokens[$prev]['line']) { // Check the spacing, but then skip it. $foundLines = ($tokens[$startOfStatement]['line'] - $tokens[$prev]['line'] - 1); if ($foundLines > 0) { $error = 'Expected 0 blank lines after member var comment; %s found'; $data = [$foundLines]; $fix = $phpcsFile->addFixableError($error, $prev, 'AfterComment', $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); // Inline comments have the newline included in the content but // docblock do not. if ($tokens[$prev]['code'] === T_COMMENT) { $phpcsFile->fixer->replaceToken($prev, rtrim($tokens[$prev]['content'])); } for ($i = ($prev + 1); $i <= $startOfStatement; $i++) { if ($tokens[$i]['line'] === $tokens[$startOfStatement]['line']) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->addNewline($prev); $phpcsFile->fixer->endChangeset(); } }//end if $start = $prev; }//end if }//end if // There needs to be n blank lines before the var, not counting comments. if ($start === $startOfStatement) { // No comment found. $first = $phpcsFile->findFirstOnLine(Tokens::$emptyTokens, $start, true); if ($first === false) { $first = $start; } } else if ($tokens[$start]['code'] === T_DOC_COMMENT_CLOSE_TAG) { $first = $tokens[$start]['comment_opener']; } else { $first = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($start - 1), null, true); $first = $phpcsFile->findNext(Tokens::$commentTokens, ($first + 1)); } // Determine if this is the first member var. $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($first - 1), null, true); if ($tokens[$prev]['code'] === T_CLOSE_CURLY_BRACKET && isset($tokens[$prev]['scope_condition']) === true && $tokens[$tokens[$prev]['scope_condition']]['code'] === T_FUNCTION ) { return; } if ($tokens[$prev]['code'] === T_OPEN_CURLY_BRACKET && isset(Tokens::$ooScopeTokens[$tokens[$tokens[$prev]['scope_condition']]['code']]) === true ) { $errorMsg = 'Expected %s blank line(s) before first member var; %s found'; $errorCode = 'FirstIncorrect'; $spacing = (int) $this->spacingBeforeFirst; } else { $errorMsg = 'Expected %s blank line(s) before member var; %s found'; $errorCode = 'Incorrect'; $spacing = (int) $this->spacing; } $foundLines = ($tokens[$first]['line'] - $tokens[$prev]['line'] - 1); if ($errorCode === 'FirstIncorrect') { $phpcsFile->recordMetric($stackPtr, 'Member var spacing before first', $foundLines); } else { $phpcsFile->recordMetric($stackPtr, 'Member var spacing before', $foundLines); } if ($foundLines === $spacing) { if ($endOfStatement !== false) { return $endOfStatement; } return; } $data = [ $spacing, $foundLines, ]; $fix = $phpcsFile->addFixableError($errorMsg, $startOfStatement, $errorCode, $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = ($prev + 1); $i < $first; $i++) { if ($tokens[$i]['line'] === $tokens[$prev]['line']) { continue; } if ($tokens[$i]['line'] === $tokens[$first]['line']) { for ($x = 1; $x <= $spacing; $x++) { $phpcsFile->fixer->addNewlineBefore($i); } break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); }//end if if ($endOfStatement !== false) { return $endOfStatement; } return; }//end processMemberVar() /** * Processes normal variables. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param int $stackPtr The position where the token was found. * * @return void */ protected function processVariable(File $phpcsFile, $stackPtr) { /* We don't care about normal variables. */ }//end processVariable() /** * Processes variables in double quoted strings. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where this token was found. * @param int $stackPtr The position where the token was found. * * @return void */ protected function processVariableInString(File $phpcsFile, $stackPtr) { /* We don't care about normal variables. */ }//end processVariableInString() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/WhiteSpace/ObjectOperatorSpacingSniff.php0000644000076500000240000001241113614652362031353 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\WhiteSpace; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class ObjectOperatorSpacingSniff implements Sniff { /** * Allow newlines instead of spaces. * * @var boolean */ public $ignoreNewlines = false; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_OBJECT_OPERATOR, T_DOUBLE_COLON, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if ($tokens[($stackPtr - 1)]['code'] !== T_WHITESPACE) { $before = 0; } else { if ($tokens[($stackPtr - 2)]['line'] !== $tokens[$stackPtr]['line']) { $before = 'newline'; } else { $before = $tokens[($stackPtr - 1)]['length']; } } $phpcsFile->recordMetric($stackPtr, 'Spacing before object operator', $before); $this->checkSpacingBeforeOperator($phpcsFile, $stackPtr, $before); if (isset($tokens[($stackPtr + 1)]) === false || isset($tokens[($stackPtr + 2)]) === false ) { return; } if ($tokens[($stackPtr + 1)]['code'] !== T_WHITESPACE) { $after = 0; } else { if ($tokens[($stackPtr + 2)]['line'] !== $tokens[$stackPtr]['line']) { $after = 'newline'; } else { $after = $tokens[($stackPtr + 1)]['length']; } } $phpcsFile->recordMetric($stackPtr, 'Spacing after object operator', $after); $this->checkSpacingAfterOperator($phpcsFile, $stackPtr, $after); }//end process() /** * Check the spacing before the operator. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param mixed $before The number of spaces found before the * operator or the string 'newline'. * * @return boolean true if there was no error, false otherwise. */ protected function checkSpacingBeforeOperator(File $phpcsFile, $stackPtr, $before) { if ($before !== 0 && ($before !== 'newline' || $this->ignoreNewlines === false) ) { $error = 'Space found before object operator'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Before'); if ($fix === true) { $tokens = $phpcsFile->getTokens(); $curPos = ($stackPtr - 1); $phpcsFile->fixer->beginChangeset(); while ($tokens[$curPos]['code'] === T_WHITESPACE) { $phpcsFile->fixer->replaceToken($curPos, ''); --$curPos; } $phpcsFile->fixer->endChangeset(); } return false; } return true; }//end checkSpacingBeforeOperator() /** * Check the spacing after the operator. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * @param mixed $after The number of spaces found after the * operator or the string 'newline'. * * @return boolean true if there was no error, false otherwise. */ protected function checkSpacingAfterOperator(File $phpcsFile, $stackPtr, $after) { if ($after !== 0 && ($after !== 'newline' || $this->ignoreNewlines === false) ) { $error = 'Space found after object operator'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'After'); if ($fix === true) { $tokens = $phpcsFile->getTokens(); $curPos = ($stackPtr + 1); $phpcsFile->fixer->beginChangeset(); while ($tokens[$curPos]['code'] === T_WHITESPACE) { $phpcsFile->fixer->replaceToken($curPos, ''); ++$curPos; } $phpcsFile->fixer->endChangeset(); } return false; } return true; }//end checkSpacingAfterOperator() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/WhiteSpace/OperatorSpacingSniff.php0000644000076500000240000003436413614652362030237 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\WhiteSpace; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class OperatorSpacingSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * Allow newlines instead of spaces. * * @var boolean */ public $ignoreNewlines = false; /** * Don't check spacing for assignment operators. * * This allows multiple assignment statements to be aligned. * * @var boolean */ public $ignoreSpacingBeforeAssignments = true; /** * A list of tokens that aren't considered as operands. * * @var string[] */ private $nonOperandTokens = []; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { /* First we setup an array of all the tokens that can come before a T_MINUS or T_PLUS token to indicate that the token is not being used as an operator. */ // Trying to operate on a negative value; eg. ($var * -1). $this->nonOperandTokens = Tokens::$operators; // Trying to compare a negative value; eg. ($var === -1). $this->nonOperandTokens += Tokens::$comparisonTokens; // Trying to compare a negative value; eg. ($var || -1 === $b). $this->nonOperandTokens += Tokens::$booleanOperators; // Trying to assign a negative value; eg. ($var = -1). $this->nonOperandTokens += Tokens::$assignmentTokens; // Returning/printing a negative value; eg. (return -1). $this->nonOperandTokens += [ T_RETURN => T_RETURN, T_ECHO => T_ECHO, T_PRINT => T_PRINT, T_YIELD => T_YIELD, ]; // Trying to use a negative value; eg. myFunction($var, -2). $this->nonOperandTokens += [ T_COMMA => T_COMMA, T_OPEN_PARENTHESIS => T_OPEN_PARENTHESIS, T_OPEN_SQUARE_BRACKET => T_OPEN_SQUARE_BRACKET, T_OPEN_SHORT_ARRAY => T_OPEN_SHORT_ARRAY, T_DOUBLE_ARROW => T_DOUBLE_ARROW, T_COLON => T_COLON, T_INLINE_THEN => T_INLINE_THEN, T_INLINE_ELSE => T_INLINE_ELSE, T_CASE => T_CASE, T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET, ]; // Casting a negative value; eg. (array) -$a. $this->nonOperandTokens += [ T_ARRAY_CAST => T_ARRAY_CAST, T_BOOL_CAST => T_BOOL_CAST, T_DOUBLE_CAST => T_DOUBLE_CAST, T_INT_CAST => T_INT_CAST, T_OBJECT_CAST => T_OBJECT_CAST, T_STRING_CAST => T_STRING_CAST, T_UNSET_CAST => T_UNSET_CAST, ]; /* These are the tokens the sniff is looking for. */ $targets = Tokens::$comparisonTokens; $targets += Tokens::$operators; $targets += Tokens::$assignmentTokens; $targets[] = T_INLINE_THEN; $targets[] = T_INLINE_ELSE; $targets[] = T_INSTANCEOF; return $targets; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being checked. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if ($this->isOperator($phpcsFile, $stackPtr) === false) { return; } if ($tokens[$stackPtr]['code'] === T_BITWISE_AND) { // Check there is one space before the & operator. if ($tokens[($stackPtr - 1)]['code'] !== T_WHITESPACE) { $error = 'Expected 1 space before "&" operator; 0 found'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NoSpaceBeforeAmp'); if ($fix === true) { $phpcsFile->fixer->addContentBefore($stackPtr, ' '); } $phpcsFile->recordMetric($stackPtr, 'Space before operator', 0); } else { if ($tokens[($stackPtr - 2)]['line'] !== $tokens[$stackPtr]['line']) { $found = 'newline'; } else { $found = $tokens[($stackPtr - 1)]['length']; } $phpcsFile->recordMetric($stackPtr, 'Space before operator', $found); if ($found !== 1 && ($found !== 'newline' || $this->ignoreNewlines === false) ) { $error = 'Expected 1 space before "&" operator; %s found'; $data = [$found]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpacingBeforeAmp', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($stackPtr - 1), ' '); } } }//end if $hasNext = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($hasNext === false) { // Live coding/parse error at end of file. return; } // Check there is one space after the & operator. if ($tokens[($stackPtr + 1)]['code'] !== T_WHITESPACE) { $error = 'Expected 1 space after "&" operator; 0 found'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NoSpaceAfterAmp'); if ($fix === true) { $phpcsFile->fixer->addContent($stackPtr, ' '); } $phpcsFile->recordMetric($stackPtr, 'Space after operator', 0); } else { if ($tokens[($stackPtr + 2)]['line'] !== $tokens[$stackPtr]['line']) { $found = 'newline'; } else { $found = $tokens[($stackPtr + 1)]['length']; } $phpcsFile->recordMetric($stackPtr, 'Space after operator', $found); if ($found !== 1 && ($found !== 'newline' || $this->ignoreNewlines === false) ) { $error = 'Expected 1 space after "&" operator; %s found'; $data = [$found]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpacingAfterAmp', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($stackPtr + 1), ' '); } } }//end if return; }//end if $operator = $tokens[$stackPtr]['content']; if ($tokens[($stackPtr - 1)]['code'] !== T_WHITESPACE && (($tokens[($stackPtr - 1)]['code'] === T_INLINE_THEN && $tokens[($stackPtr)]['code'] === T_INLINE_ELSE) === false) ) { $error = "Expected 1 space before \"$operator\"; 0 found"; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NoSpaceBefore'); if ($fix === true) { $phpcsFile->fixer->addContentBefore($stackPtr, ' '); } $phpcsFile->recordMetric($stackPtr, 'Space before operator', 0); } else if (isset(Tokens::$assignmentTokens[$tokens[$stackPtr]['code']]) === false || $this->ignoreSpacingBeforeAssignments === false ) { // Throw an error for assignments only if enabled using the sniff property // because other standards allow multiple spaces to align assignments. if ($tokens[($stackPtr - 2)]['line'] !== $tokens[$stackPtr]['line']) { $found = 'newline'; } else { $found = $tokens[($stackPtr - 1)]['length']; } $phpcsFile->recordMetric($stackPtr, 'Space before operator', $found); if ($found !== 1 && ($found !== 'newline' || $this->ignoreNewlines === false) ) { $error = 'Expected 1 space before "%s"; %s found'; $data = [ $operator, $found, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpacingBefore', $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); if ($found === 'newline') { $i = ($stackPtr - 2); while ($tokens[$i]['code'] === T_WHITESPACE) { $phpcsFile->fixer->replaceToken($i, ''); $i--; } } $phpcsFile->fixer->replaceToken(($stackPtr - 1), ' '); $phpcsFile->fixer->endChangeset(); } }//end if }//end if $hasNext = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($hasNext === false) { // Live coding/parse error at end of file. return; } if ($tokens[($stackPtr + 1)]['code'] !== T_WHITESPACE) { // Skip short ternary such as: "$foo = $bar ?: true;". if (($tokens[$stackPtr]['code'] === T_INLINE_THEN && $tokens[($stackPtr + 1)]['code'] === T_INLINE_ELSE) ) { return; } $error = "Expected 1 space after \"$operator\"; 0 found"; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'NoSpaceAfter'); if ($fix === true) { $phpcsFile->fixer->addContent($stackPtr, ' '); } $phpcsFile->recordMetric($stackPtr, 'Space after operator', 0); } else { if (isset($tokens[($stackPtr + 2)]) === true && $tokens[($stackPtr + 2)]['line'] !== $tokens[$stackPtr]['line'] ) { $found = 'newline'; } else { $found = $tokens[($stackPtr + 1)]['length']; } $phpcsFile->recordMetric($stackPtr, 'Space after operator', $found); if ($found !== 1 && ($found !== 'newline' || $this->ignoreNewlines === false) ) { $error = 'Expected 1 space after "%s"; %s found'; $data = [ $operator, $found, ]; $nextNonWhitespace = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); if ($nextNonWhitespace !== false && isset(Tokens::$commentTokens[$tokens[$nextNonWhitespace]['code']]) === true && $found === 'newline' ) { // Don't auto-fix when it's a comment or PHPCS annotation on a new line as // it causes fixer conflicts and can cause the meaning of annotations to change. $phpcsFile->addError($error, $stackPtr, 'SpacingAfter', $data); } else { $fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpacingAfter', $data); if ($fix === true) { $phpcsFile->fixer->replaceToken(($stackPtr + 1), ' '); } } }//end if }//end if }//end process() /** * Checks if an operator is actually a different type of token in the current context. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The current file being checked. * @param int $stackPtr The position of the operator in * the stack. * * @return boolean */ protected function isOperator(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // Skip default values in function declarations. // Skip declare statements. if ($tokens[$stackPtr]['code'] === T_EQUAL || $tokens[$stackPtr]['code'] === T_MINUS ) { if (isset($tokens[$stackPtr]['nested_parenthesis']) === true) { $parenthesis = array_keys($tokens[$stackPtr]['nested_parenthesis']); $bracket = array_pop($parenthesis); if (isset($tokens[$bracket]['parenthesis_owner']) === true) { $function = $tokens[$bracket]['parenthesis_owner']; if ($tokens[$function]['code'] === T_FUNCTION || $tokens[$function]['code'] === T_CLOSURE || $tokens[$function]['code'] === T_DECLARE ) { return false; } } } } if ($tokens[$stackPtr]['code'] === T_EQUAL) { // Skip for '=&' case. if (isset($tokens[($stackPtr + 1)]) === true && $tokens[($stackPtr + 1)]['code'] === T_BITWISE_AND ) { return false; } } if ($tokens[$stackPtr]['code'] === T_BITWISE_AND) { // If it's not a reference, then we expect one space either side of the // bitwise operator. if ($phpcsFile->isReference($stackPtr) === true) { return false; } } if ($tokens[$stackPtr]['code'] === T_MINUS || $tokens[$stackPtr]['code'] === T_PLUS) { // Check minus spacing, but make sure we aren't just assigning // a minus value or returning one. $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); if (isset($this->nonOperandTokens[$tokens[$prev]['code']]) === true) { return false; } }//end if return true; }//end isOperator() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/WhiteSpace/PropertyLabelSpacingSniff.php0000644000076500000240000000452213614652362031221 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\WhiteSpace; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class PropertyLabelSpacingSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = ['JS']; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_PROPERTY, T_LABEL, ]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $colon = $phpcsFile->findNext(T_COLON, ($stackPtr + 1)); if ($colon !== ($stackPtr + 1)) { $error = 'There must be no space before the colon in a property/label declaration'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Before'); if ($fix === true) { $phpcsFile->fixer->replaceToken(($stackPtr + 1), ''); } } if ($tokens[($colon + 1)]['code'] !== T_WHITESPACE || $tokens[($colon + 1)]['content'] !== ' ') { $error = 'There must be a single space after the colon in a property/label declaration'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'After'); if ($fix === true) { if ($tokens[($colon + 1)]['code'] === T_WHITESPACE) { $phpcsFile->fixer->replaceToken(($colon + 1), ' '); } else { $phpcsFile->fixer->addContent($colon, ' '); } } } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/WhiteSpace/ScopeClosingBraceSniff.php0000644000076500000240000000750013614652362030454 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\WhiteSpace; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class ScopeClosingBraceSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return Tokens::$scopeOpeners; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile All the tokens found in the document. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); // If this is an inline condition (ie. there is no scope opener), then // return, as this is not a new scope. if (isset($tokens[$stackPtr]['scope_closer']) === false) { return; } // We need to actually find the first piece of content on this line, // as if this is a method with tokens before it (public, static etc) // or an if with an else before it, then we need to start the scope // checking from there, rather than the current token. $lineStart = $phpcsFile->findFirstOnLine([T_WHITESPACE, T_INLINE_HTML], $stackPtr, true); while ($tokens[$lineStart]['code'] === T_CONSTANT_ENCAPSED_STRING && $tokens[($lineStart - 1)]['code'] === T_CONSTANT_ENCAPSED_STRING ) { $lineStart = $phpcsFile->findFirstOnLine([T_WHITESPACE, T_INLINE_HTML], ($lineStart - 1), true); } $startColumn = $tokens[$lineStart]['column']; $scopeStart = $tokens[$stackPtr]['scope_opener']; $scopeEnd = $tokens[$stackPtr]['scope_closer']; // Check that the closing brace is on it's own line. $lastContent = $phpcsFile->findPrevious([T_INLINE_HTML, T_WHITESPACE, T_OPEN_TAG], ($scopeEnd - 1), $scopeStart, true); if ($tokens[$lastContent]['line'] === $tokens[$scopeEnd]['line']) { $error = 'Closing brace must be on a line by itself'; $fix = $phpcsFile->addFixableError($error, $scopeEnd, 'ContentBefore'); if ($fix === true) { $phpcsFile->fixer->addNewlineBefore($scopeEnd); } return; } // Check now that the closing brace is lined up correctly. $lineStart = $phpcsFile->findFirstOnLine([T_WHITESPACE, T_INLINE_HTML], $scopeEnd, true); $braceIndent = $tokens[$lineStart]['column']; if ($tokens[$stackPtr]['code'] !== T_DEFAULT && $tokens[$stackPtr]['code'] !== T_CASE && $braceIndent !== $startColumn ) { $error = 'Closing brace indented incorrectly; expected %s spaces, found %s'; $data = [ ($startColumn - 1), ($braceIndent - 1), ]; $fix = $phpcsFile->addFixableError($error, $scopeEnd, 'Indent', $data); if ($fix === true) { $diff = ($startColumn - $braceIndent); if ($diff > 0) { $phpcsFile->fixer->addContentBefore($lineStart, str_repeat(' ', $diff)); } else { $phpcsFile->fixer->substrToken(($lineStart - 1), 0, $diff); } } }//end if }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/WhiteSpace/ScopeKeywordSpacingSniff.php0000644000076500000240000001014013614652362031044 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\WhiteSpace; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class ScopeKeywordSpacingSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { $register = Tokens::$scopeModifiers; $register[] = T_STATIC; return $register; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (isset($tokens[($stackPtr + 1)]) === false) { return; } $prevToken = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true); $nextToken = $phpcsFile->findNext(Tokens::$emptyTokens, ($stackPtr + 1), null, true); if ($tokens[$stackPtr]['code'] === T_STATIC && (($nextToken === false || $tokens[$nextToken]['code'] === T_DOUBLE_COLON) || $tokens[$prevToken]['code'] === T_NEW) ) { // Late static binding, e.g., static:: OR new static() usage or live coding. return; } if ($tokens[$prevToken]['code'] === T_AS) { // Trait visibility change, e.g., "use HelloWorld { sayHello as private; }". return; } if ($nextToken !== false && $tokens[$nextToken]['code'] === T_VARIABLE) { $endOfStatement = $phpcsFile->findNext(T_SEMICOLON, ($nextToken + 1)); if ($endOfStatement === false) { // Live coding. return; } $multiProperty = $phpcsFile->findNext(T_VARIABLE, ($nextToken + 1), $endOfStatement); if ($multiProperty !== false && $tokens[$stackPtr]['line'] !== $tokens[$nextToken]['line'] && $tokens[$nextToken]['line'] !== $tokens[$endOfStatement]['line'] ) { // Allow for multiple properties definitions to each be on their own line. return; } } if ($tokens[($stackPtr + 1)]['code'] !== T_WHITESPACE) { $spacing = 0; } else { if ($tokens[($stackPtr + 2)]['line'] !== $tokens[$stackPtr]['line']) { $spacing = 'newline'; } else { $spacing = $tokens[($stackPtr + 1)]['length']; } } if ($spacing !== 1) { $error = 'Scope keyword "%s" must be followed by a single space; found %s'; $data = [ $tokens[$stackPtr]['content'], $spacing, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Incorrect', $data); if ($fix === true) { if ($spacing === 0) { $phpcsFile->fixer->addContent($stackPtr, ' '); } else { $phpcsFile->fixer->beginChangeset(); for ($i = ($stackPtr + 2); $i < $phpcsFile->numTokens; $i++) { if (isset($tokens[$i]) === false || $tokens[$i]['code'] !== T_WHITESPACE) { break; } $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->replaceToken(($stackPtr + 1), ' '); $phpcsFile->fixer->endChangeset(); } }//end if }//end if }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/WhiteSpace/SemicolonSpacingSniff.php0000644000076500000240000000676613614652362030401 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\WhiteSpace; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Util\Tokens; class SemicolonSpacingSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', ]; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_SEMICOLON]; }//end register() /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token * in the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $prevType = $tokens[($stackPtr - 1)]['code']; if (isset(Tokens::$emptyTokens[$prevType]) === false) { return; } $nonSpace = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 2), null, true); // Detect whether this is a semi-colons for a conditions in a `for()` control structure. $forCondition = false; if (isset($tokens[$stackPtr]['nested_parenthesis']) === true) { $nestedParens = $tokens[$stackPtr]['nested_parenthesis']; $closeParenthesis = end($nestedParens); if (isset($tokens[$closeParenthesis]['parenthesis_owner']) === true) { $owner = $tokens[$closeParenthesis]['parenthesis_owner']; if ($tokens[$owner]['code'] === T_FOR) { $forCondition = true; $nonSpace = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 2), null, true); } } } if ($tokens[$nonSpace]['code'] === T_SEMICOLON || ($forCondition === true && $nonSpace === $tokens[$owner]['parenthesis_opener']) ) { // Empty statement. return; } $expected = $tokens[$nonSpace]['content'].';'; $found = $phpcsFile->getTokensAsString($nonSpace, ($stackPtr - $nonSpace)).';'; $found = str_replace("\n", '\n', $found); $found = str_replace("\r", '\r', $found); $found = str_replace("\t", '\t', $found); $error = 'Space found before semicolon; expected "%s" but found "%s"'; $data = [ $expected, $found, ]; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'Incorrect', $data); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $i = ($stackPtr - 1); while (($tokens[$i]['code'] === T_WHITESPACE) && ($i > $nonSpace)) { $phpcsFile->fixer->replaceToken($i, ''); $i--; } $phpcsFile->fixer->addContent($nonSpace, ';'); $phpcsFile->fixer->replaceToken($stackPtr, ''); $phpcsFile->fixer->endChangeset(); } }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Sniffs/WhiteSpace/SuperfluousWhitespaceSniff.php0000644000076500000240000002342013614652362031477 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Sniffs\WhiteSpace; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Sniffs\Sniff; class SuperfluousWhitespaceSniff implements Sniff { /** * A list of tokenizers this sniff supports. * * @var array */ public $supportedTokenizers = [ 'PHP', 'JS', 'CSS', ]; /** * If TRUE, whitespace rules are not checked for blank lines. * * Blank lines are those that contain only whitespace. * * @var boolean */ public $ignoreBlankLines = false; /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [ T_OPEN_TAG, T_CLOSE_TAG, T_WHITESPACE, T_COMMENT, T_DOC_COMMENT_WHITESPACE, T_CLOSURE, ]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if ($tokens[$stackPtr]['code'] === T_OPEN_TAG) { /* Check for start of file whitespace. */ if ($phpcsFile->tokenizerType !== 'PHP') { // The first token is always the open tag inserted when tokenized // and the second token is always the first piece of content in // the file. If the second token is whitespace, there was // whitespace at the start of the file. if ($tokens[($stackPtr + 1)]['code'] !== T_WHITESPACE) { return; } if ($phpcsFile->fixer->enabled === true) { $stackPtr = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true); } } else { // If it's the first token, then there is no space. if ($stackPtr === 0) { return; } $beforeOpen = ''; for ($i = ($stackPtr - 1); $i >= 0; $i--) { // If we find something that isn't inline html then there is something previous in the file. if ($tokens[$i]['type'] !== 'T_INLINE_HTML') { return; } $beforeOpen .= $tokens[$i]['content']; } // If we have ended up with inline html make sure it isn't just whitespace. if (preg_match('`^[\pZ\s]+$`u', $beforeOpen) !== 1) { return; } }//end if $fix = $phpcsFile->addFixableError('Additional whitespace found at start of file', $stackPtr, 'StartFile'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); for ($i = 0; $i < $stackPtr; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } } else if ($tokens[$stackPtr]['code'] === T_CLOSE_TAG) { /* Check for end of file whitespace. */ if ($phpcsFile->tokenizerType === 'PHP') { if (isset($tokens[($stackPtr + 1)]) === false) { // The close PHP token is the last in the file. return; } $afterClose = ''; for ($i = ($stackPtr + 1); $i < $phpcsFile->numTokens; $i++) { // If we find something that isn't inline HTML then there // is more to the file. if ($tokens[$i]['type'] !== 'T_INLINE_HTML') { return; } $afterClose .= $tokens[$i]['content']; } // If we have ended up with inline html make sure it isn't just whitespace. if (preg_match('`^[\pZ\s]+$`u', $afterClose) !== 1) { return; } } else { // The last token is always the close tag inserted when tokenized // and the second last token is always the last piece of content in // the file. If the second last token is whitespace, there was // whitespace at the end of the file. $stackPtr--; // The pointer is now looking at the last content in the file and // not the fake PHP end tag the tokenizer inserted. if ($tokens[$stackPtr]['code'] !== T_WHITESPACE) { return; } // Allow a single newline at the end of the last line in the file. if ($tokens[($stackPtr - 1)]['code'] !== T_WHITESPACE && $tokens[$stackPtr]['content'] === $phpcsFile->eolChar ) { return; } }//end if $fix = $phpcsFile->addFixableError('Additional whitespace found at end of file', $stackPtr, 'EndFile'); if ($fix === true) { if ($phpcsFile->tokenizerType !== 'PHP') { $prev = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true); $stackPtr = ($prev + 1); } $phpcsFile->fixer->beginChangeset(); for ($i = ($stackPtr + 1); $i < $phpcsFile->numTokens; $i++) { $phpcsFile->fixer->replaceToken($i, ''); } $phpcsFile->fixer->endChangeset(); } } else { /* Check for end of line whitespace. */ // Ignore whitespace that is not at the end of a line. if (isset($tokens[($stackPtr + 1)]['line']) === true && $tokens[($stackPtr + 1)]['line'] === $tokens[$stackPtr]['line'] ) { return; } // Ignore blank lines if required. if ($this->ignoreBlankLines === true && $tokens[$stackPtr]['code'] === T_WHITESPACE && $tokens[($stackPtr - 1)]['line'] !== $tokens[$stackPtr]['line'] ) { return; } $tokenContent = rtrim($tokens[$stackPtr]['content'], $phpcsFile->eolChar); if (empty($tokenContent) === false) { if ($tokenContent !== rtrim($tokenContent)) { $fix = $phpcsFile->addFixableError('Whitespace found at end of line', $stackPtr, 'EndLine'); if ($fix === true) { $phpcsFile->fixer->replaceToken($stackPtr, rtrim($tokenContent).$phpcsFile->eolChar); } } } else if ($tokens[($stackPtr - 1)]['content'] !== rtrim($tokens[($stackPtr - 1)]['content']) && $tokens[($stackPtr - 1)]['line'] === $tokens[$stackPtr]['line'] ) { $fix = $phpcsFile->addFixableError('Whitespace found at end of line', ($stackPtr - 1), 'EndLine'); if ($fix === true) { $phpcsFile->fixer->replaceToken(($stackPtr - 1), rtrim($tokens[($stackPtr - 1)]['content'])); } } /* Check for multiple blank lines in a function. */ if (($phpcsFile->hasCondition($stackPtr, [T_FUNCTION, T_CLOSURE]) === true) && $tokens[($stackPtr - 1)]['line'] < $tokens[$stackPtr]['line'] && $tokens[($stackPtr - 2)]['line'] === $tokens[($stackPtr - 1)]['line'] ) { // Properties and functions in nested classes have their own rules for spacing. $conditions = $tokens[$stackPtr]['conditions']; $deepestScope = end($conditions); if ($deepestScope === T_ANON_CLASS) { return; } // This is an empty line and the line before this one is not // empty, so this could be the start of a multiple empty // line block. $next = $phpcsFile->findNext(T_WHITESPACE, $stackPtr, null, true); $lines = ($tokens[$next]['line'] - $tokens[$stackPtr]['line']); if ($lines > 1) { $error = 'Functions must not contain multiple empty lines in a row; found %s empty lines'; $fix = $phpcsFile->addFixableError($error, $stackPtr, 'EmptyLines', [$lines]); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $i = $stackPtr; while ($tokens[$i]['line'] !== $tokens[$next]['line']) { $phpcsFile->fixer->replaceToken($i, ''); $i++; } $phpcsFile->fixer->addNewlineBefore($i); $phpcsFile->fixer->endChangeset(); } } }//end if }//end if }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Arrays/ArrayBracketSpacingUnitTest.inc0000644000076500000240000000133513614652362030561 0ustar gsherwoodstaff 'bar', 'bar' => 'foo', ]; if ($foo) {} [$a, $b] = $c; echo foo()[ 1 ]; echo $this->addedCustomFunctions['nonce']; echo $this->deprecated_functions[ $function_name ]['version']; echo [ 1,2,3 ][0]; echo [ 1,2,3 ][ 0 ]; echo 'PHP'[ 0 ]; $array = []; $var = $var[$var[$var]]]; // Syntax error $var = $var[$var[$var]; // Syntax error $myArray[ /* key start */'key'] = $value; $myArray[ /* key start */'key'/* key end */ ] = $value; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Arrays/ArrayBracketSpacingUnitTest.inc.fixed0000644000076500000240000000131013614652362031650 0ustar gsherwoodstaff 'bar', 'bar' => 'foo', ]; if ($foo) {} [$a, $b] = $c; echo foo()[1]; echo $this->addedCustomFunctions['nonce']; echo $this->deprecated_functions[$function_name]['version']; echo [ 1,2,3 ][0]; echo [ 1,2,3 ][0]; echo 'PHP'[0]; $array = []; $var = $var[$var[$var]]]; // Syntax error $var = $var[$var[$var]; // Syntax error $myArray[/* key start */'key'] = $value; $myArray[/* key start */'key'/* key end */] = $value; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Arrays/ArrayBracketSpacingUnitTest.php0000644000076500000240000000252713614652362030603 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Arrays; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ArrayBracketSpacingUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 5 => 3, 7 => 3, 17 => 2, 20 => 2, 23 => 2, 24 => 2, 30 => 1, 31 => 2, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Arrays/ArrayDeclarationUnitTest.1.inc0000644000076500000240000001724313614652362030272 0ustar gsherwoodstaff 1, ); } class TestClass { public $good = array( 'width' => '', 'height' => '', ); private $_bad = Array( 'width' => '', 'height' => '' ); public function test() { $truck = array( 'width' => '', 'height' => '', ); $plane = Array( 'width' => '', 'height' => '', ); $car = array( 'width' => '', 'height' => '', ); $bus = array( 'width' => '', 'height' => '' ); $train = array ( TRUE, FALSE, 'aaa' ); $inline = array('aaa', 'bbb', 'ccc'); $inline = array('aaa'); $inline = Array('aaa'); $bigone = array( 'name' => 'bigone', 'children' => Array( '1a' => 'child', '11b' => 'child', '111c' => 'child', 'children' => Array( 'child' => 'aaa', ), ), 'short_name' => 'big' ); } }//end class $value = array ( ); $value = array( ); $value = array('1'=>$one, '2' => $two, '3'=> $three, '4' =>$four); $value = array('1'=>$one); if (in_array('1', array('1','2','3')) === TRUE) { $value = in_array('1', array('1' , '2', '3','4')); } $value = array( '1'=> TRUE, FALSE, '3' => 'aaa',); $value = array( '1'=> TRUE, FALSE, ); $value = array( TRUE, '1' => FALSE, ); $value = array(1, 2 , 3 , ); $value = array(1 => $one, 2 => $two , 3 => $three , ); $value = array( 'tag' => $tag, 'space' => $this->_getIndentation($tag, $tagElement), ); $expected = array( array( '1' => 1, '1' => 2, ), ); $expected = array( array( '1' => 1, '1' => 2 ) ); // Space in second arg. $args = array( '"'.$this->id.'"', (int) $hasSessions, ); // No errors. $paths = array( Init::ROOT_DIR.'/Systems' => 'Systems', Init::ROOT_DIR.'/Installer' => 'Systems', ); $x = array( ); $x = array('test' ); $x = array('test', ); $x = array('name' => 'test', ); $x = array( $x, ); $func = array( $x, 'get'.$x.'Replacement' ); $array = array( 'input_one' => 'one', 'inputTwo' => 'two', 'input_3' => 3, ); $array = array( 'input_one', 'inputTwo', 'input_3', ); // Malformed $foo = array(1 , 2); $listItems[$aliasPath] = array('itemContent' => implode('
    ', $aliases)); $listItems[$aliasPath] = array( 'itemContent' => implode('
    ', $aliases) ); $x = array ( $x, $y, ); $x = array ( $x, $y, ); $x = array( $x, $y, ); $test = array( 'test' => TestFunction::blah( $value1, $value2 ), ); $c = array('a' => 1,); function b() { $a = array( 'a' => a('a'), ); } $foo = Array('[',']',':',"\n","\r"); $bar = Array('[',']',':',' ',' '); function foo() { return array($a, $b->screen); } $array = array( 'name' => 'contactSubject', 'required' => TRUE, 'validators' => array( new \Zend\Validator\InArray(array('haystack' => array_keys($aSubjects))), ), ); $var = array( 'ViewHelper', array('Foo'), 'Errors', ); $data = array( 'first', 'second', 'third', // Add more here ); $data = array( 'first', 'second', //'third', ); $data = array( 'first', 'second' //'third', ); $foo = array( $this->getViewName() . '.id' => 'value', $this->getViewName() . '.title' => 'value', ); $foo = array( $this->getViewName() . '.id', $this->getViewName() . '.title', ); $weightings = array( T_CLOSURE => 100, /* Conditions. */ T_WHILE => 50, /* Operators and arithmetic. */ T_BITWISE_AND => 8, T_BOOLEAN_AND => 5, /* Equality. */ T_IS_GREATER_OR_EQUAL => 5, ); foreach (array( 'foo' => 'bar', 'foobaz' => 'bazzy', ) as $key => $value) { } $ids = array( '1', // Foo. '13', // Bar. ); array( 'key1' => function($bar) { return $bar; }, 'key2' => function($foo) { return $foo; }, 'key3' => function($bar) { return $bar; } ); array( 'key1' => array( '1', '2', ) ); $var = array( 'tab_template' => '
  • %s
    • ', 'panel_template' => '
    %s
    ', ); function test() : array { return []; } $fields = array( 'id' => array('type' => 'INT'), 'value' => array('type' => 'VARCHAR')); get_current_screen()->add_help_tab( array( 'id' => << false); $x = array( 'xxxx' => array('aaaaaaaaaa' => 'ccccccccccc', 'bbbbbbbb' => false), ); $foo = array ('foo' => array ('bar1' => 1 ,'bar2' => 1 ,'bar3' => 1 ,'bar4' => 1 ,'bar5' => 1 ) ); $foo = array( '1' => $row['status'] === 'rejected' ? self::REJECTED_CODE : self::VERIFIED_CODE, '2' => in_array($row['status'], array('notverified', 'unverified'), true) ? self::STATUS_PENDING : self::STATUS_VERIFIED, '3' => strtotime($row['date']), ); $foo = foo( array( // comment ) ); $foo = array( << 'авто', 'цвет' => 'синий', ); $paths = array( Init::ROOT_DIR.'/тип' => 'авто', Init::ROOT_DIR.'/цвет' => 'синий', ); $foo = array(<< fn() => return 1, 'bb' => fn() => return 2, 'ccc' => ( true ) ? fn() => return 1 : fn() => return 2, ); $array = array( 1 => '1', 2 => fn ($x) => yield 'a' => $x, 3 => '3', ); // Intentional syntax error. $a = array( 'a' => ); PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Arrays/ArrayDeclarationUnitTest.1.inc.fixed0000644000076500000240000001766513614652362031400 0ustar gsherwoodstaff 1); } class TestClass { public $good = array( 'width' => '', 'height' => '', ); private $_bad = array( 'width' => '', 'height' => '', ); public function test() { $truck = array( 'width' => '', 'height' => '', ); $plane = array( 'width' => '', 'height' => '', ); $car = array( 'width' => '', 'height' => '', ); $bus = array( 'width' => '', 'height' => '', ); $train = array( TRUE, FALSE, 'aaa', ); $inline = array( 'aaa', 'bbb', 'ccc', ); $inline = array('aaa'); $inline = array('aaa'); $bigone = array( 'name' => 'bigone', 'children' => array( '1a' => 'child', '11b' => 'child', '111c' => 'child', 'children' => array('child' => 'aaa'), ), 'short_name' => 'big', ); } }//end class $value = array(); $value = array(); $value = array( '1' => $one, '2' => $two, '3' => $three, '4' => $four, ); $value = array('1' => $one); if (in_array('1', array('1', '2', '3')) === TRUE) { $value = in_array('1', array('1', '2', '3', '4')); } $value = array( '1'=> TRUE, FALSE, '3' => 'aaa', ); $value = array( '1'=> TRUE, FALSE, ); $value = array( TRUE, '1' => FALSE, ); $value = array( 1, 2, 3, ); $value = array( 1 => $one, 2 => $two, 3 => $three, ); $value = array( 'tag' => $tag, 'space' => $this->_getIndentation($tag, $tagElement), ); $expected = array( array( '1' => 1, '1' => 2, ), ); $expected = array( array( '1' => 1, '1' => 2, ), ); // Space in second arg. $args = array( '"'.$this->id.'"', (int) $hasSessions, ); // No errors. $paths = array( Init::ROOT_DIR.'/Systems' => 'Systems', Init::ROOT_DIR.'/Installer' => 'Systems', ); $x = array(); $x = array('test'); $x = array('test'); $x = array('name' => 'test'); $x = array($x); $func = array( $x, 'get'.$x.'Replacement', ); $array = array( 'input_one' => 'one', 'inputTwo' => 'two', 'input_3' => 3, ); $array = array( 'input_one', 'inputTwo', 'input_3', ); // Malformed $foo = array( 1, 2, ); $listItems[$aliasPath] = array('itemContent' => implode('
    ', $aliases)); $listItems[$aliasPath] = array( 'itemContent' => implode('
    ', $aliases), ); $x = array( $x, $y, ); $x = array( $x, $y, ); $x = array( $x, $y, ); $test = array( 'test' => TestFunction::blah( $value1, $value2 ), ); $c = array('a' => 1); function b() { $a = array( 'a' => a('a'), ); } $foo = array( '[', ']', ':', "\n", "\r", ); $bar = array( '[', ']', ':', ' ', ' ', ); function foo() { return array( $a, $b->screen, ); } $array = array( 'name' => 'contactSubject', 'required' => TRUE, 'validators' => array( new \Zend\Validator\InArray(array('haystack' => array_keys($aSubjects))), ), ); $var = array( 'ViewHelper', array('Foo'), 'Errors', ); $data = array( 'first', 'second', 'third', // Add more here ); $data = array( 'first', 'second', //'third', ); $data = array( 'first', 'second', //'third', ); $foo = array( $this->getViewName() . '.id' => 'value', $this->getViewName() . '.title' => 'value', ); $foo = array( $this->getViewName() . '.id', $this->getViewName() . '.title', ); $weightings = array( T_CLOSURE => 100, /* Conditions. */ T_WHILE => 50, /* Operators and arithmetic. */ T_BITWISE_AND => 8, T_BOOLEAN_AND => 5, /* Equality. */ T_IS_GREATER_OR_EQUAL => 5, ); foreach (array( 'foo' => 'bar', 'foobaz' => 'bazzy', ) as $key => $value) { } $ids = array( '1', // Foo. '13', // Bar. ); array( 'key1' => function($bar) { return $bar; }, 'key2' => function($foo) { return $foo; }, 'key3' => function($bar) { return $bar; }, ); array( 'key1' => array( '1', '2', ), ); $var = array( 'tab_template' => '
  • %s
    • ', 'panel_template' => '
    %s
    ', ); function test() : array { return []; } $fields = array( 'id' => array('type' => 'INT'), 'value' => array('type' => 'VARCHAR'), ); get_current_screen()->add_help_tab( array( 'id' => << false); $x = array( 'xxxx' => array( 'aaaaaaaaaa' => 'ccccccccccc', 'bbbbbbbb' => false, ), ); $foo = array( 'foo' => array( 'bar1' => 1, 'bar2' => 1, 'bar3' => 1, 'bar4' => 1, 'bar5' => 1, ), ); $foo = array( '1' => $row['status'] === 'rejected' ? self::REJECTED_CODE : self::VERIFIED_CODE, '2' => in_array($row['status'], array('notverified', 'unverified'), true) ? self::STATUS_PENDING : self::STATUS_VERIFIED, '3' => strtotime($row['date']), ); $foo = foo( array( // comment ) ); $foo = array( << 'авто', 'цвет' => 'синий', ); $paths = array( Init::ROOT_DIR.'/тип' => 'авто', Init::ROOT_DIR.'/цвет' => 'синий', ); $foo = array(<< fn() => return 1, 'bb' => fn() => return 2, 'ccc' => ( true ) ? fn() => return 1 : fn() => return 2, ); $array = array( 1 => '1', 2 => fn ($x) => yield 'a' => $x, 3 => '3', ); // Intentional syntax error. $a = array( 'a' => ); PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Arrays/ArrayDeclarationUnitTest.2.inc0000644000076500000240000001624213614652362030271 0ustar gsherwoodstaff 1, ]; } class TestClass { public $good = [ 'width' => '', 'height' => '', ]; private $_bad = [ 'width' => '', 'height' => '' ]; public function test() { $truck = [ 'width' => '', 'height' => '', ]; $plane = [ 'width' => '', 'height' => '', ]; $car = [ 'width' => '', 'height' => '', ]; $bus = [ 'width' => '', 'height' => '' ]; $train = [ TRUE, FALSE, 'aaa' ]; $inline = ['aaa', 'bbb', 'ccc']; $inline = ['aaa']; $inline = ['aaa']; $bigone = [ 'name' => 'bigone', 'children' => [ '1a' => 'child', '11b' => 'child', '111c' => 'child', 'children' => [ 'child' => 'aaa', ], ], 'short_name' => 'big' ]; } }//end class $value = [ ]; $value = [ ]; $value = ['1'=>$one, '2' => $two, '3'=> $three, '4' =>$four]; $value = ['1'=>$one]; if (in_array('1', ['1','2','3']) === TRUE) { $value = in_array('1', ['1' , '2', '3','4']); } $value = [ '1'=> TRUE, FALSE, '3' => 'aaa',]; $value = [ '1'=> TRUE, FALSE, ]; $value = [ TRUE, '1' => FALSE, ]; $value = [1, 2 , 3 , ]; $value = [1 => $one, 2 => $two , 3 => $three , ]; $value = [ 'tag' => $tag, 'space' => $this->_getIndentation($tag, $tagElement), ]; $expected = [ [ '1' => 1, '1' => 2, ], ]; $expected = [ [ '1' => 1, '1' => 2 ] ]; // Space in second arg. $args = [ '"'.$this->id.'"', (int) $hasSessions, ]; // No errors. $paths = [ Init::ROOT_DIR.'/Systems' => 'Systems', Init::ROOT_DIR.'/Installer' => 'Systems', ]; $x = [ ]; $x = ['test' ]; $x = ['test', ]; $x = ['name' => 'test', ]; $x = [ $x, ]; $func = [ $x, 'get'.$x.'Replacement' ]; $array = [ 'input_one' => 'one', 'inputTwo' => 'two', 'input_3' => 3, ]; $array = [ 'input_one', 'inputTwo', 'input_3', ]; // Malformed $foo = [1 , 2]; $listItems[$aliasPath] = ['itemContent' => implode('
    ', $aliases)]; $listItems[$aliasPath] = [ 'itemContent' => implode('
    ', $aliases) ]; $x = [ $x, $y, ]; $x = [ $x, $y, ]; $x = [ $x, $y, ]; $test = [ 'test' => TestFunction::blah( $value1, $value2 ), ]; $c = ['a' => 1,]; $c->{$var}[ ] = 2; $foo = ['[',']',':',"\n","\r"]; $bar = ['[',']',':',' ',' ']; function foo() { return [$a, $b->screen]; } $array = [ 'name' => 'contactSubject', 'required' => TRUE, 'validators' => [ new \Zend\Validator\InArray(['haystack' => array_keys($aSubjects)]), ], ]; $var = [ 'ViewHelper', ['Foo'], 'Errors', ]; $data = [ 'first', 'second', 'third', // Add more here ]; $data = [ 'first', 'second', //'third', ]; $data = [ 'first', 'second' //'third', ]; $foo = [ $this->getViewName() . '.id' => 'value', $this->getViewName() . '.title' => 'value', ]; $foo = [ $this->getViewName() . '.id', $this->getViewName() . '.title', ]; $weightings = [ T_CLOSURE => 100, /* Conditions. */ T_WHILE => 50, /* Operators and arithmetic. */ T_BITWISE_AND => 8, T_BOOLEAN_AND => 5, /* Equality. */ T_IS_GREATER_OR_EQUAL => 5, ]; foreach ([ 'foo' => 'bar', 'foobaz' => 'bazzy', ] as $key => $value) { } $ids = [ '1', // Foo. '13', // Bar. ]; [ 'key1' => function($bar) { return $bar; }, 'key2' => function($foo) { return $foo; }, 'key3' => function($bar) { return $bar; } ]; [ 'key1' => [ '1', '2', ] ]; $var = [ 'tab_template' => '
  • %s
    • ', 'panel_template' => '
    %s
    ', ]; function test() : array { return []; } $fields = [ 'id' => ['type' => 'INT'], 'value' => ['type' => 'VARCHAR']]; get_current_screen()->add_help_tab( [ 'id' => << false]; $x = [ 'xxxx' => ['aaaaaaaaaa' => 'ccccccccccc', 'bbbbbbbb' => false], ]; $foo = ['foo' => ['bar1' => 1 ,'bar2' => 1 ,'bar3' => 1 ,'bar4' => 1 ,'bar5' => 1 ] ]; $foo = [ '1' => $row['status'] === 'rejected' ? self::REJECTED_CODE : self::VERIFIED_CODE, '2' => in_array($row['status'], ['notverified', 'unverified'], true) ? self::STATUS_PENDING : self::STATUS_VERIFIED, '3' => strtotime($row['date']), ]; $foo = foo( [ // comment ] ); $foo = [ << 'авто', 'цвет' => 'синий', ]; $paths = [ Init::ROOT_DIR.'/тип' => 'авто', Init::ROOT_DIR.'/цвет' => 'синий', ]; $foo = [<< fn() => return 1, 'bb' => fn() => return 2, 'ccc' => ( true ) ? fn() => return 1 : fn() => return 2, ]; $array = [ 1 => '1', 2 => fn ($x) => yield 'a' => $x, 3 => '3', ]; // Intentional syntax error. $a = [ 'a' => ]; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Arrays/ArrayDeclarationUnitTest.2.inc.fixed0000644000076500000240000001664113614652362031372 0ustar gsherwoodstaff 1]; } class TestClass { public $good = [ 'width' => '', 'height' => '', ]; private $_bad = [ 'width' => '', 'height' => '', ]; public function test() { $truck = [ 'width' => '', 'height' => '', ]; $plane = [ 'width' => '', 'height' => '', ]; $car = [ 'width' => '', 'height' => '', ]; $bus = [ 'width' => '', 'height' => '', ]; $train = [ TRUE, FALSE, 'aaa', ]; $inline = [ 'aaa', 'bbb', 'ccc', ]; $inline = ['aaa']; $inline = ['aaa']; $bigone = [ 'name' => 'bigone', 'children' => [ '1a' => 'child', '11b' => 'child', '111c' => 'child', 'children' => ['child' => 'aaa'], ], 'short_name' => 'big', ]; } }//end class $value = []; $value = []; $value = [ '1' => $one, '2' => $two, '3' => $three, '4' => $four, ]; $value = ['1' => $one]; if (in_array('1', ['1', '2', '3']) === TRUE) { $value = in_array('1', ['1', '2', '3', '4']); } $value = [ '1'=> TRUE, FALSE, '3' => 'aaa', ]; $value = [ '1'=> TRUE, FALSE, ]; $value = [ TRUE, '1' => FALSE, ]; $value = [ 1, 2, 3, ]; $value = [ 1 => $one, 2 => $two, 3 => $three, ]; $value = [ 'tag' => $tag, 'space' => $this->_getIndentation($tag, $tagElement), ]; $expected = [ [ '1' => 1, '1' => 2, ], ]; $expected = [ [ '1' => 1, '1' => 2, ], ]; // Space in second arg. $args = [ '"'.$this->id.'"', (int) $hasSessions, ]; // No errors. $paths = [ Init::ROOT_DIR.'/Systems' => 'Systems', Init::ROOT_DIR.'/Installer' => 'Systems', ]; $x = []; $x = ['test']; $x = ['test']; $x = ['name' => 'test']; $x = [$x]; $func = [ $x, 'get'.$x.'Replacement', ]; $array = [ 'input_one' => 'one', 'inputTwo' => 'two', 'input_3' => 3, ]; $array = [ 'input_one', 'inputTwo', 'input_3', ]; // Malformed $foo = [ 1, 2, ]; $listItems[$aliasPath] = ['itemContent' => implode('
    ', $aliases)]; $listItems[$aliasPath] = [ 'itemContent' => implode('
    ', $aliases), ]; $x = [ $x, $y, ]; $x = [ $x, $y, ]; $x = [ $x, $y, ]; $test = [ 'test' => TestFunction::blah( $value1, $value2 ), ]; $c = ['a' => 1]; $c->{$var}[ ] = 2; $foo = [ '[', ']', ':', "\n", "\r", ]; $bar = [ '[', ']', ':', ' ', ' ', ]; function foo() { return [ $a, $b->screen, ]; } $array = [ 'name' => 'contactSubject', 'required' => TRUE, 'validators' => [ new \Zend\Validator\InArray(['haystack' => array_keys($aSubjects)]), ], ]; $var = [ 'ViewHelper', ['Foo'], 'Errors', ]; $data = [ 'first', 'second', 'third', // Add more here ]; $data = [ 'first', 'second', //'third', ]; $data = [ 'first', 'second', //'third', ]; $foo = [ $this->getViewName() . '.id' => 'value', $this->getViewName() . '.title' => 'value', ]; $foo = [ $this->getViewName() . '.id', $this->getViewName() . '.title', ]; $weightings = [ T_CLOSURE => 100, /* Conditions. */ T_WHILE => 50, /* Operators and arithmetic. */ T_BITWISE_AND => 8, T_BOOLEAN_AND => 5, /* Equality. */ T_IS_GREATER_OR_EQUAL => 5, ]; foreach ([ 'foo' => 'bar', 'foobaz' => 'bazzy', ] as $key => $value) { } $ids = [ '1', // Foo. '13', // Bar. ]; [ 'key1' => function($bar) { return $bar; }, 'key2' => function($foo) { return $foo; }, 'key3' => function($bar) { return $bar; }, ]; [ 'key1' => [ '1', '2', ], ]; $var = [ 'tab_template' => '
  • %s
    • ', 'panel_template' => '
    %s
    ', ]; function test() : array { return []; } $fields = [ 'id' => ['type' => 'INT'], 'value' => ['type' => 'VARCHAR'], ]; get_current_screen()->add_help_tab( [ 'id' => << false]; $x = [ 'xxxx' => [ 'aaaaaaaaaa' => 'ccccccccccc', 'bbbbbbbb' => false, ], ]; $foo = [ 'foo' => [ 'bar1' => 1, 'bar2' => 1, 'bar3' => 1, 'bar4' => 1, 'bar5' => 1, ], ]; $foo = [ '1' => $row['status'] === 'rejected' ? self::REJECTED_CODE : self::VERIFIED_CODE, '2' => in_array($row['status'], ['notverified', 'unverified'], true) ? self::STATUS_PENDING : self::STATUS_VERIFIED, '3' => strtotime($row['date']), ]; $foo = foo( [ // comment ] ); $foo = [ << 'авто', 'цвет' => 'синий', ]; $paths = [ Init::ROOT_DIR.'/тип' => 'авто', Init::ROOT_DIR.'/цвет' => 'синий', ]; $foo = [<< fn() => return 1, 'bb' => fn() => return 2, 'ccc' => ( true ) ? fn() => return 1 : fn() => return 2, ]; $array = [ 1 => '1', 2 => fn ($x) => yield 'a' => $x, 3 => '3', ]; // Intentional syntax error. $a = [ 'a' => ]; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Arrays/ArrayDeclarationUnitTest.php0000644000076500000240000001264113614652362030146 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Arrays; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ArrayDeclarationUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='') { switch ($testFile) { case 'ArrayDeclarationUnitTest.1.inc': return [ 2 => 1, 8 => 2, 10 => 2, 22 => 1, 23 => 2, 24 => 2, 25 => 1, 31 => 2, 35 => 1, 36 => 2, 41 => 1, 46 => 1, 47 => 1, 50 => 1, 51 => 1, 53 => 1, 56 => 1, 58 => 1, 61 => 1, 62 => 1, 63 => 1, 64 => 1, 65 => 1, 66 => 3, 70 => 1, 76 => 2, 77 => 1, 78 => 7, 79 => 2, 81 => 2, 82 => 4, 87 => 1, 88 => 1, 92 => 1, 97 => 1, 100 => 1, 101 => 1, 102 => 1, 105 => 1, 106 => 1, 107 => 1, 125 => 1, 126 => 1, 141 => 1, 144 => 1, 146 => 1, 148 => 1, 151 => 1, 157 => 1, 174 => 3, 179 => 1, 182 => 1, 188 => 1, 207 => 1, 212 => 2, 214 => 1, 218 => 2, 219 => 2, 223 => 1, 255 => 1, 294 => 1, 295 => 1, 296 => 1, 311 => 1, 317 => 1, 339 => 2, 348 => 2, 352 => 2, 355 => 3, 358 => 3, 359 => 2, 360 => 1, 362 => 1, 363 => 2, 364 => 1, 365 => 2, 366 => 2, 367 => 2, 368 => 2, 369 => 1, 370 => 1, 383 => 1, 394 => 1, ]; case 'ArrayDeclarationUnitTest.2.inc': return [ 2 => 1, 10 => 1, 23 => 2, 24 => 2, 25 => 1, 31 => 2, 36 => 2, 41 => 1, 46 => 1, 47 => 1, 51 => 1, 53 => 1, 56 => 1, 61 => 1, 63 => 1, 64 => 1, 65 => 1, 66 => 2, 70 => 1, 76 => 1, 77 => 1, 78 => 7, 79 => 2, 81 => 2, 82 => 4, 87 => 1, 88 => 1, 92 => 1, 97 => 1, 100 => 1, 101 => 1, 102 => 1, 105 => 1, 106 => 1, 107 => 1, 125 => 1, 126 => 1, 141 => 1, 144 => 1, 146 => 1, 148 => 1, 151 => 1, 157 => 1, 174 => 3, 179 => 1, 190 => 1, 191 => 1, 192 => 1, 207 => 1, 210 => 1, 211 => 1, 215 => 1, 247 => 1, 286 => 1, 287 => 1, 288 => 1, 303 => 1, 309 => 1, 331 => 2, 345 => 3, 348 => 3, 349 => 2, 350 => 1, 352 => 2, 353 => 2, 354 => 2, 355 => 2, 356 => 2, 357 => 1, 358 => 1, 372 => 1, 383 => 1, ]; default: return []; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Classes/ClassDeclarationUnitTest.inc0000644000076500000240000000330213614652362030245 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Classes; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ClassDeclarationUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 5 => 1, 6 => 1, 10 => 1, 15 => 2, 18 => 1, 22 => 4, 23 => 4, 24 => 4, 27 => 2, 30 => 2, 34 => 1, 35 => 1, 39 => 1, 42 => 1, 45 => 1, 48 => 1, 50 => 2, 51 => 1, 55 => 1, 59 => 4, 63 => 1, 65 => 1, 69 => 3, 74 => 2, 77 => 1, 80 => 1, 85 => 3, 89 => 1, 92 => 1, 97 => 1, 108 => 1, 114 => 1, 116 => 1, 118 => 1, 121 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Classes/ClassFileNameUnitTest.inc0000644000076500000240000000173113614652362027504 0ustar gsherwoodstaffPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Classes/ClassFileNameUnitTest.php0000644000076500000240000000313513614652362027522 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Classes; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ClassFileNameUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 11 => 1, 12 => 1, 13 => 1, 14 => 1, 15 => 1, 16 => 1, 17 => 1, 18 => 1, 19 => 1, 23 => 1, 24 => 1, 25 => 1, 26 => 1, 27 => 1, 28 => 1, 29 => 1, 30 => 1, 31 => 1, 32 => 1, 33 => 1, 34 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Classes/DuplicatePropertyUnitTest.js0000644000076500000240000000140413614652362030355 0ustar gsherwoodstaffvar x = { abc: 1, zyz: 2, abc: 5, mno: { abc: 4 }, abc: 5 this.request({ action: 'getSubmissions' }); this.request({ action: 'deleteSubmission' }); } LinkingEditScreenWidgetType.prototype = { _addDeleteButtonEvent: function(parentid) { var params = { screen: 'LinkingEditScreenWidget', assetid: self.assetid, parentid: parentid, assetid: parentid, op: 'deleteLink' }; }, saveDesignEdit: function() { var params = { screen: [this.id, 'Widget'].join(''), assetid: this.assetid, changes: dfx.jsonEncode(this.currnetLinksWdgt.getChanges()), op: 'saveLinkEdit' }; } };PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Classes/DuplicatePropertyUnitTest.php0000644000076500000240000000235313614652362030534 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Classes; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class DuplicatePropertyUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 4 => 1, 8 => 1, 28 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Classes/LowercaseClassKeywordsUnitTest.inc0000644000076500000240000000034213614652362031475 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Classes; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class LowercaseClassKeywordsUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { $errors = [ 2 => 3, 3 => 3, 4 => 1, 5 => 1, 9 => 1, 10 => 1, 13 => 1, ]; return $errors; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Classes/SelfMemberReferenceUnitTest.inc0000644000076500000240000000665413614652362030707 0ustar gsherwoodstafftestResults; // Correct call to self. $testResults[] = self::selfMemberReferenceUnitTestFunction(); $testResults[] = parent::selfMemberReferenceUnitTestFunction(); // Incorrect case. $testResults[] = Self::selfMemberReferenceUnitTestFunction(); $testResults[] = SELF::selfMemberReferenceUnitTestFunction(); $testResults[] = SelfMemberReferenceUnitTestExample::selfMemberReferenceUnitTestFunction(); // Incorrect spacing. $testResults[] = self ::selfMemberReferenceUnitTestFunction(); $testResults[] = self:: selfMemberReferenceUnitTestFunction(); $testResults[] = self :: selfMemberReferenceUnitTestFunction(); // Remove ALL the newlines $testResults[] = self :: selfMemberReferenceUnitTestFunction(); } function selfMemberReferenceUnitTestFunction() { $this->testCount = $this->testCount + 1; return $this->testCount; } } class MyClass { public static function test($value) { echo "$value\n"; } public static function walk() { $callback = function($value, $key) { // This is valid because you can't use self:: in a closure. MyClass::test($value); }; $array = array(1,2,3); array_walk($array, $callback); } } MyClass::walk(); class Controller { public function Action() { Doctrine\Common\Util\Debug::dump(); } } class Foo { public static function bar() { \Foo::baz(); } } namespace TYPO3\CMS\Reports; class Status { const NOTICE = -2; const INFO = -1; const OK = 0; const WARNING = 1; const ERROR = 2; } namespace TYPO3\CMS\Reports\Report\Status; class Status implements \TYPO3\CMS\Reports\ReportInterface { public function getHighestSeverity(array $statusCollection) { $highestSeverity = \TYPO3\CMS\Reports\Status::NOTICE; } } namespace Foo; class Bar { function myFunction() { \Foo\Whatever::something(); \Foo\Bar::something(); } } namespace Foo\Bar; class Baz { function myFunction() { \Foo\Bar\Whatever::something(); \Foo\Bar\Baz::something(); } } class Nested_Anon_Class { public function getAnonymousClass() { // Spacing/comments should not cause false negatives for the NotUsed error. Nested_Anon_Class :: $prop; Nested_Anon_Class /* some comment */ :: // phpcs:ignore Standard.Category.SniffName -- for reasons. Bar(); // Anonymous class is a different scope. return new class() { public function nested_function() { Nested_Anon_Class::$prop; Nested_Anon_Class::BAR; } }; } } // Test dealing with scoped namespaces. namespace Foo\Baz { class BarFoo { public function foo() { echo Foo\Baz\BarFoo::$prop; } } } // Prevent false negative when namespace has whitespace/comments. namespace Foo /*comment*/ \ Bah { class BarFoo { public function foo() { echo Foo \ /*comment*/ Bah\BarFoo::$prop; } } } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Classes/SelfMemberReferenceUnitTest.inc.fixed0000644000076500000240000000643313614652362032000 0ustar gsherwoodstafftestResults; // Correct call to self. $testResults[] = self::selfMemberReferenceUnitTestFunction(); $testResults[] = parent::selfMemberReferenceUnitTestFunction(); // Incorrect case. $testResults[] = self::selfMemberReferenceUnitTestFunction(); $testResults[] = self::selfMemberReferenceUnitTestFunction(); $testResults[] = self::selfMemberReferenceUnitTestFunction(); // Incorrect spacing. $testResults[] = self::selfMemberReferenceUnitTestFunction(); $testResults[] = self::selfMemberReferenceUnitTestFunction(); $testResults[] = self::selfMemberReferenceUnitTestFunction(); // Remove ALL the newlines $testResults[] = self::selfMemberReferenceUnitTestFunction(); } function selfMemberReferenceUnitTestFunction() { $this->testCount = $this->testCount + 1; return $this->testCount; } } class MyClass { public static function test($value) { echo "$value\n"; } public static function walk() { $callback = function($value, $key) { // This is valid because you can't use self:: in a closure. MyClass::test($value); }; $array = array(1,2,3); array_walk($array, $callback); } } MyClass::walk(); class Controller { public function Action() { Doctrine\Common\Util\Debug::dump(); } } class Foo { public static function bar() { self::baz(); } } namespace TYPO3\CMS\Reports; class Status { const NOTICE = -2; const INFO = -1; const OK = 0; const WARNING = 1; const ERROR = 2; } namespace TYPO3\CMS\Reports\Report\Status; class Status implements \TYPO3\CMS\Reports\ReportInterface { public function getHighestSeverity(array $statusCollection) { $highestSeverity = \TYPO3\CMS\Reports\Status::NOTICE; } } namespace Foo; class Bar { function myFunction() { \Foo\Whatever::something(); self::something(); } } namespace Foo\Bar; class Baz { function myFunction() { \Foo\Bar\Whatever::something(); self::something(); } } class Nested_Anon_Class { public function getAnonymousClass() { // Spacing/comments should not cause false negatives for the NotUsed error. self::$prop; /* some comment */ self::// phpcs:ignore Standard.Category.SniffName -- for reasons. Bar(); // Anonymous class is a different scope. return new class() { public function nested_function() { Nested_Anon_Class::$prop; Nested_Anon_Class::BAR; } }; } } // Test dealing with scoped namespaces. namespace Foo\Baz { class BarFoo { public function foo() { echo self::$prop; } } } // Prevent false negative when namespace has whitespace/comments. namespace Foo /*comment*/ \ Bah { class BarFoo { public function foo() { echo /*comment*/ self::$prop; } } } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Classes/SelfMemberReferenceUnitTest.php0000644000076500000240000000277213614652362030722 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Classes; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class SelfMemberReferenceUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 24 => 1, 25 => 1, 26 => 1, 30 => 1, 31 => 1, 32 => 2, 40 => 2, 92 => 1, 121 => 1, 132 => 1, 139 => 3, 140 => 1, 143 => 2, 162 => 1, 171 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Classes/ValidClassNameUnitTest.inc0000644000076500000240000000705013614652362027664 0ustar gsherwoodstaffanonymous = new class extends ArrayObject { public function __construct() { parent::__construct(['a' => 1, 'b' => 2]); } }; } } // Valid interface name. interface ValidCamelCaseClass extends MyClass {} // Incorrect usage of camel case. interface invalidCamelCaseClass extends MyClass {} interface Invalid_Camel_Case_Class_With_Underscores implements MyClass {} // All lowercase. interface invalidlowercaseclass extends MyClass {} interface invalid_lowercase_class_with_underscores extends MyClass {} // All uppercase. interface VALIDUPPERCASECLASS extends MyClass {} interface INVALID_UPPERCASE_CLASS_WITH_UNDERSCORES extends MyClass {} // Mix camel case with uppercase. interface ValidCamelCaseClassWithUPPERCASE extends MyClass {} // Usage of numeric characters. interface ValidCamelCaseClassWith1Number extends MyClass {} interface ValidCamelCaseClassWith12345Numbers extends MyClass {} interface 5InvalidCamelCaseClassStartingWithNumber extends MyClass {} interface ValidCamelCaseClassEndingWithNumber5 extends MyClass {} interface 12345 extends MyClass {} interface Testing{} interface Base { protected $anonymous; public function __construct(); } // Valid trait name. trait ValidCamelCaseClass extends MyClass {} // Incorrect usage of camel case. trait invalidCamelCaseClass extends MyClass {} trait Invalid_Camel_Case_Class_With_Underscores implements MyClass {} // All lowercase. trait invalidlowercaseclass extends MyClass {} trait invalid_lowercase_class_with_underscores extends MyClass {} // All uppercase. trait VALIDUPPERCASECLASS extends MyClass {} trait INVALID_UPPERCASE_CLASS_WITH_UNDERSCORES extends MyClass {} // Mix camel case with uppercase. trait ValidCamelCaseClassWithUPPERCASE extends MyClass {} // Usage of numeric characters. trait ValidCamelCaseClassWith1Number extends MyClass {} trait ValidCamelCaseClassWith12345Numbers extends MyClass {} trait 5InvalidCamelCaseClassStartingWithNumber extends MyClass {} trait ValidCamelCaseClassEndingWithNumber5 extends MyClass {} trait 12345 extends MyClass {} trait Testing{} trait Base { protected $anonymous; public function __construct() { $this->anonymous = new class extends ArrayObject { public function __construct() { parent::__construct(['a' => 1, 'b' => 2]); } }; } } if ( class_exists( Test :: class ) ) {} if ( class_exists( Test2 ::class ) ) {} $foo = new class( new class implements Countable { } ) extends DateTime { }; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Classes/ValidClassNameUnitTest.php0000644000076500000240000000316413614652362027704 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Classes; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ValidClassNameUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 9 => 1, 10 => 1, 14 => 1, 15 => 1, 20 => 1, 30 => 1, 32 => 1, 57 => 1, 58 => 1, 62 => 1, 63 => 1, 68 => 1, 78 => 1, 80 => 1, 97 => 1, 98 => 1, 102 => 1, 103 => 1, 108 => 1, 118 => 1, 120 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/BlockCommentUnitTest.inc0000644000076500000240000000720513614652362030120 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Commenting; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class BlockCommentUnitTest extends AbstractSniffUnitTest { /** * Get a list of CLI values to set before the file is tested. * * @param string $testFile The name of the file being tested. * @param \PHP_CodeSniffer\Config $config The config data for the test run. * * @return void */ public function setCliValues($testFile, $config) { $config->tabWidth = 4; }//end setCliValues() /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { $errors = [ 3 => 1, 8 => 1, 20 => 1, 24 => 1, 30 => 1, 31 => 1, 34 => 1, 40 => 1, 45 => 1, 49 => 1, 51 => 1, 53 => 1, 57 => 1, 60 => 1, 61 => 1, 63 => 1, 65 => 1, 68 => 1, 70 => 1, 72 => 1, 75 => 1, 84 => 1, 87 => 1, 89 => 1, 92 => 1, 111 => 1, 159 => 1, 181 => 1, 188 => 1, 208 => 1, 214 => 1, 226 => 1, 227 => 1, 232 => 1, 233 => 1, 256 => 1, ]; return $errors; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/ClassCommentUnitTest.inc0000644000076500000240000000244613614652362030135 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Commenting; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ClassCommentUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 2 => 1, 15 => 1, 31 => 1, 54 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return [ 29 => 1, 30 => 1, 50 => 1, 66 => 1, 67 => 1, ]; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/ClosingDeclarationCommentUnitTest.inc0000644000076500000240000000202313614652362032623 0ustar gsherwoodstaffPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/ClosingDeclarationCommentUnitTest.php0000644000076500000240000000255613614652362032654 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Commenting; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ClosingDeclarationCommentUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 13 => 1, 17 => 1, 31 => 1, 41 => 1, 59 => 1, 63 => 1, 67 => 1, 79 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return [71 => 1]; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/DocCommentAlignmentUnitTest.inc0000644000076500000240000000262713614652362031435 0ustar gsherwoodstaff line numbers for each token. * * Long description with some points: * - one * - two * - three * * @param array &$tokens The array of tokens to process. * @param object $tokenizer The tokenizer being used to * process this file. * @param string $eolChar The EOL character to use for splitting strings. * * @return void */ function myFunction() {} class MyClass2 { /** * Some info about the variable here. */ var $x; } /** ************************************************************************ * Example with no errors. **************************************************************************/ function example() {} PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/DocCommentAlignmentUnitTest.inc.fixed0000644000076500000240000000262013614652362032524 0ustar gsherwoodstaff line numbers for each token. * * Long description with some points: * - one * - two * - three * * @param array &$tokens The array of tokens to process. * @param object $tokenizer The tokenizer being used to * process this file. * @param string $eolChar The EOL character to use for splitting strings. * * @return void */ function myFunction() {} class MyClass2 { /** * Some info about the variable here. */ var $x; } /** ************************************************************************ * Example with no errors. **************************************************************************/ function example() {} PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/DocCommentAlignmentUnitTest.js0000644000076500000240000000234313614652362031273 0ustar gsherwoodstaff /** * Some info about the class here * */ foo.prototype = { /** * Some info about the function here. * *@return void */ bar: function() {} } /** * Some info about the class here * */ foo.prototype = { /** *Some info about the function here. * * @return void */ bar: function() {} } /** * Some info about the class here * */ foo.prototype = { /** * Some info about the function here. * * @return void */ bar: function() {} } /** @var Database $mockedDatabase */ /** @var Container $mockedContainer */ function myFunction() { console.info('hi'); /** Comment here. */ } /** * Creates a map of tokens => line numbers for each token. * * Long description with some points: * - one * - two * - three * * @param array &$tokens The array of tokens to process. * @param object $tokenizer The tokenizer being used to * process this file. * @param string $eolChar The EOL character to use for splitting strings. * * @return void */ function myFunction() {} $.extend(Datepicker.prototype, { _widgetDatepicker: function() { }, /* Action for selecting a new month/year. */ }); PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/DocCommentAlignmentUnitTest.js.fixed0000644000076500000240000000233613614652362032373 0ustar gsherwoodstaff /** * Some info about the class here * */ foo.prototype = { /** * Some info about the function here. * * @return void */ bar: function() {} } /** * Some info about the class here * */ foo.prototype = { /** * Some info about the function here. * * @return void */ bar: function() {} } /** * Some info about the class here * */ foo.prototype = { /** * Some info about the function here. * * @return void */ bar: function() {} } /** @var Database $mockedDatabase */ /** @var Container $mockedContainer */ function myFunction() { console.info('hi'); /** Comment here. */ } /** * Creates a map of tokens => line numbers for each token. * * Long description with some points: * - one * - two * - three * * @param array &$tokens The array of tokens to process. * @param object $tokenizer The tokenizer being used to * process this file. * @param string $eolChar The EOL character to use for splitting strings. * * @return void */ function myFunction() {} $.extend(Datepicker.prototype, { _widgetDatepicker: function() { }, /* Action for selecting a new month/year. */ }); PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/DocCommentAlignmentUnitTest.php0000644000076500000240000000327313614652362031451 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Commenting; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class DocCommentAlignmentUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='DocCommentAlignmentUnitTest.inc') { $errors = [ 3 => 1, 11 => 1, 17 => 1, 18 => 1, 19 => 1, 23 => 2, 24 => 1, 25 => 2, 26 => 1, 32 => 1, 33 => 1, 38 => 1, 39 => 1, ]; if ($testFile === 'DocCommentAlignmentUnitTest.inc') { $errors[75] = 1; } return $errors; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/EmptyCatchCommentUnitTest.inc0000644000076500000240000000154113614652362031124 0ustar gsherwoodstaffPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/EmptyCatchCommentUnitTest.php0000644000076500000240000000245513614652362031147 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Commenting; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class EmptyCatchCommentUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 13 => 1, 33 => 1, 49 => 1, 50 => 1, 51 => 1, 52 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/FileCommentUnitTest.1.inc0000644000076500000240000000172613614652362030106 0ustar gsherwoodstaff * @author * @copyright 1997~1994 The PHP Group * @copyright 1994-1997 The PHP Group * @copyright The PHP Group * @license http://www.php.net/license/3_0.txt * @summary An unknown summary tag * */ ?> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/FileCommentUnitTest.1.inc.fixed0000644000076500000240000000177613614652362031211 0ustar gsherwoodstaff * @author * @copyright 1997 Squiz Pty Ltd (ABN 77 084 670 600) * @copyright 1994-1997 Squiz Pty Ltd (ABN 77 084 670 600) * @copyright 2020 Squiz Pty Ltd (ABN 77 084 670 600) * @license http://www.php.net/license/3_0.txt * @summary An unknown summary tag * */ ?> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/FileCommentUnitTest.2.inc0000644000076500000240000000031413614652362030077 0ustar gsherwoodstaff * @copyright 2010-2014 Squiz Pty Ltd (ABN 77 084 670 600) */ echo 'hi';PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/FileCommentUnitTest.3.inc0000644000076500000240000000030013614652362030073 0ustar gsherwoodstaff * @copyright 2010-2014 Squiz Pty Ltd (ABN 77 084 670 600) * PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/FileCommentUnitTest.4.inc0000644000076500000240000000004413614652362030101 0ustar gsherwoodstaff * @copyright 2010-2014 Squiz Pty Ltd (ABN 77 084 670 600) */ class Foo { } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/FileCommentUnitTest.1.js0000644000076500000240000000171213614652362027744 0ustar gsherwoodstaff /** * * 0Multi-line short description without full stop * * * asdasd * long description for file (if any) * asdasdadada * * PHP versio * * LICENSE: This source file is subject to version 3.0 of the PHP license * that is available through the world-wide-web at the following URI: * http://www.php.net/license/3_0.txt. If you did not receive a copy of * the PHP License and are unable to obtain it through the web, please * send a note to license@php.net so we can mail you a copy immediately. * @package SquizCMS * @package ADDITIONAL PACKAGE TAG * @subpkg not_camelcased * @author Antônio Carlos Venâncio Júnior * @author * @copyright 1997~1994 The PHP Group * @copyright 1994-1997 The PHP Group * @copyright The PHP Group * @license http://www.php.net/license/3_0.txt * @summary An unknown summary tag * */ /** * This bit here is not qualified as file comment * * as it is not the first comment in the file * */ PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/FileCommentUnitTest.1.js.fixed0000644000076500000240000000176213614652362031047 0ustar gsherwoodstaff /** * * 0Multi-line short description without full stop * * * asdasd * long description for file (if any) * asdasdadada * * PHP versio * * LICENSE: This source file is subject to version 3.0 of the PHP license * that is available through the world-wide-web at the following URI: * http://www.php.net/license/3_0.txt. If you did not receive a copy of * the PHP License and are unable to obtain it through the web, please * send a note to license@php.net so we can mail you a copy immediately. * @package SquizCMS * @package ADDITIONAL PACKAGE TAG * @subpkg not_camelcased * @author Squiz Pty Ltd * @author * @copyright 1997 Squiz Pty Ltd (ABN 77 084 670 600) * @copyright 1994-1997 Squiz Pty Ltd (ABN 77 084 670 600) * @copyright 2020 Squiz Pty Ltd (ABN 77 084 670 600) * @license http://www.php.net/license/3_0.txt * @summary An unknown summary tag * */ /** * This bit here is not qualified as file comment * * as it is not the first comment in the file * */ PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/FileCommentUnitTest.2.js0000644000076500000240000000030713614652362027744 0ustar gsherwoodstaff/** * File comment. * * @package Package * @subpackage Subpackage * @author Squiz Pty Ltd * @copyright 2010-2014 Squiz Pty Ltd (ABN 77 084 670 600) */ print 'hi';PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/FileCommentUnitTest.php0000644000076500000240000000354113614652362027762 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Commenting; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class FileCommentUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='FileCommentUnitTest.inc') { switch ($testFile) { case 'FileCommentUnitTest.1.inc': case 'FileCommentUnitTest.1.js': return [ 1 => 1, 22 => 2, 23 => 1, 24 => 2, 25 => 2, 26 => 1, 27 => 2, 28 => 2, 32 => 2, ]; case 'FileCommentUnitTest.4.inc': case 'FileCommentUnitTest.6.inc': return [1 => 1]; case 'FileCommentUnitTest.5.inc': return [2 => 1]; default: return []; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/FunctionCommentThrowTagUnitTest.inc0000644000076500000240000002467513614652362032345 0ustar gsherwoodstaffcallSomeFunction(); }//end okFunction() /** * Comment inside function. * * @throws Exception */ function okFunction() { /** * @var FooClass */ $foo = FooFactory::factory(); throw new Exception; }//end okFunction /** * Needs at throws tag for rethrown exception, * even though we have one throws tag. * * @throws PHP_Exception1 */ public function notOkVariableRethrown() { throw new PHP_Exception1('Error'); try { // Do something. } catch (PHP_Exception2 $e) { logError(); throw $e; } }//end notOkVariableRethrown() /** * Needs at throws tag for rethrown exception, * even though we have one throws tag. * * @throws PHP_Exception1 */ public function notOkVariableRethrown() { throw new PHP_Exception1('Error'); try { // Do something. } catch (PHP_Exception1 | PHP_Exception2 $e) { logError(); throw $e; } }//end notOkVariableRethrown() /** * Has correct throws tags for all exceptions * * @throws PHP_Exception1 * @throws PHP_Exception2 */ public function okVariableRethrown() { throw new PHP_Exception1('Error'); try { // Do something. } catch (PHP_Exception2 $e) { logError(); throw $e; } }//end okVariableRethrown() /** * Has correct throws tags for all exceptions * * @throws PHP_Exception1 * @throws PHP_Exception2 */ public function okVariableMultiRethrown() { try { // Do something. } catch (PHP_Exception1 | PHP_Exception2 $e) { logError(); throw $e; } }//end okVariableMultiRethrown() }//end class class NamespacedException { /** * @throws \Exception */ public function foo() { throw new \Exception(); } /** * @throws \Foo\Bar\FooBarException */ public function fooBar2() { throw new \Foo\Bar\FooBarException(); } /** * @throws FooBarException */ public function fooBar2() { throw new \Foo\Bar\FooBarException(); } } class Foo { /** * Comment */ public function foo() { }//end foo() public function bar() { throw new Exception(); } /** * Returns information for a test. * * This info includes parameters, their valid values. * * @param integer $projectid Id of the project. * * @return array * @throws ChannelException If the project is invalid. */ public static function getTestInfo($projectid=NULL) { try { DAL::beginTransaction(); DAL::commit(); } catch (DALException $e) { DAL::rollBack(); throw new ChannelException($e); } } } class Test { /** * Folder name. * * @var string */ protected $folderName; protected function setUp() { parent::setUp(); if ( !strlen($this->folderName) ) { throw new \RuntimeException('The $this->folderName must be specified before proceeding.'); } } /* * */ protected function foo() { } /** * @return Closure */ public function getStuff() { return function () { throw new RuntimeException("bam!"); }; } } /** * Class comment. */ class A { /** * Function B. */ public function b() { return new class { public function c() { throw new \Exception(); } } } } /** * Class comment. */ class A { /** * Function B. */ public function b() { return new class { /** * Tag and token number mismatch. * * @throws PHP_Exception1 * @throws PHP_Exception2 */ public function oneLessThrowsTagNeeded() { throw new PHP_Exception1('Error'); }//end oneLessThrowsTagNeeded() } } } abstract class SomeClass { /** * Comment here. */ abstract public function getGroups(); } class SomeClass { /** * Validates something. * * @param string $method The set method parameter. * * @return string The validated method. * * @throws Prefix_Invalid_Argument_Exception The invalid argument exception. * @throws InvalidArgumentException The invalid argument exception. */ protected function validate_something( $something ) { if ( ! Prefix_Validator::is_string( $something ) ) { throw Prefix_Invalid_Argument_Exception::invalid_string_parameter( $something, 'something' ); } if ( ! in_array( $something, $this->valid_http_something, true ) ) { throw new InvalidArgumentException( sprintf( '%s is not a valid HTTP something', $something ) ); } return $something; } /** * Comment * * @throws Exception1 Comment. * @throws Exception2 Comment. * @throws Exception3 Comment. */ public function foo() { switch ($foo) { case 1: throw Exception1::a(); case 2: throw Exception1::b(); case 3: throw Exception1::c(); case 4: throw Exception2::a(); case 5: throw Exception2::b(); default: throw new Exception3; } } } namespace Test\Admin { class NameSpacedClass { /** * @throws \ExceptionFromGlobalNamespace */ public function ExceptionInGlobalNamespace() { throw new \ExceptionFromGlobalNamespace(); } /** * @throws ExceptionFromSameNamespace */ public function ExceptionInSameNamespace() { throw new ExceptionFromSameNamespace(); } /** * @throws \Test\Admin\ExceptionFromSameNamespace */ public function ExceptionInSameNamespaceToo() { throw new ExceptionFromSameNamespace(); } /** * @throws \Different\NameSpaceName\ExceptionFromDifferentNamespace */ public function ExceptionInSameNamespaceToo() { throw new \Different\NameSpaceName\ExceptionFromDifferentNamespace(); } } } namespace { class GlobalNameSpaceClass { /** * @throws SomeGlobalException */ public function ThrowGlobalException() { throw new SomeGlobalException(); } /** * @throws \SomeGlobalException */ public function ThrowGlobalExceptionToo() { throw new SomeGlobalException(); } } } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/FunctionCommentThrowTagUnitTest.php0000644000076500000240000000265513614652362032355 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Commenting; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class FunctionCommentThrowTagUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 9 => 1, 21 => 1, 35 => 1, 47 => 1, 61 => 2, 106 => 1, 123 => 1, 200 => 1, 219 => 1, 287 => 1, 397 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/FunctionCommentUnitTest.inc0000644000076500000240000003705013614652362030654 0ustar gsherwoodstaffMyClass) */ public function caseSensitive($a1, $a2, $a3, arRay $a4, $a5, $a6, myclas $a7) { }//end caseSensitive() /** * More type hint check for custom type and array. * * @param array $a1 Comment here. * @param array $a2 Comment here. * @param MyClass $a3 Comment here. * @param MyClass $a4 Comment here. * * @return array(int => MyClass) */ public function typeHint(MyClass $a1, $a2, myclass $a3, $a4) { return (3 => 'myclass obj'); }//end typeHint() /** * Mixed variable type separated by a '|'. * * @param array|string $a1 Comment here. * @param mixed $a2 Comment here. * @param string|array $a3 Comment here. * @param MyClass|int $a4 Comment here. * * @return bool */ public function mixedType($a1, $a2, $a3, $a4) { return true; }//end mixedType() /** * Array type. * * @param array(MyClass) $a1 OK. * @param array() $a2 Invalid type. * @param array( $a3 Typo. * @param array(int) $a4 Use 'array(integer)' instead. * @param array(int => integer) $a5 Use 'array(integer => integer)' instead. * @param array(integer => bool) $a6 Use 'array(integer => boolean)' instead. * @param aRRay $a7 Use 'array' instead. * @param string $a8 String with unknown type hint. * * @return int */ public function mixedArrayType($a1, $a2, array $a3, $a4, $a5, $a6, $a7, unknownTypeHint $a8) { return 1; }//end mixedArrayType() /** */ function empty1() { }//end empty1() /** * */ function empty2() { }//end empty2() /** * * * */ function empty3() { }//end empty3 /** * @return boolean */ public function missingShortDescriptionInFunctionComment() { return true; }//end missingShortDescriptionInFunctionComment() class Another_Class { /** * Destructor should not include a return tag. * * @return void */ function __destruct() { return; } /** * Constructor should not include a return tag. * * @return void */ function __construct() { return; } }//end class /** * Comment param alignment test. * * @param string $varrr1 Comment1.. * @param string $vr2 Comment2. * @param string $var3 Comment3.. * * @return void */ public static function paramAlign($varrr1, $vr2, $var3) { }//end paramAlign() /** * Comment. * * @param string $id Comment. * @param array $design Comment. * * @return void */ public static function paint($id, array $design) { }//end paint() /** * Adds specified class name to class attribute of this widget. * * @since 4.0.0 * @return string */ public function myFunction() { if ($condition === FALSE) { echo 'hi'; } }//end myFunction() /** * Adds specified class name to class attribute of this widget. * * @return string */ public function myFunction() { if ($condition === FALSE) { echo 'hi'; return; } return 'blah'; }//end myFunction() /** * Adds specified class name to class attribute of this widget. * * @return string */ public function myFunction() { if ($condition === FALSE) { echo 'hi'; } return 'blah'; }//end myFunction() /** * Test function. * * @param string $arg1 An argument * * @access public * @return bool */ echo $blah; function myFunction($arg1) {} class MyClass() { /** * An abstract function. * * @return string[] */ abstract final protected function myFunction(); } /** * Comment. * * @param mixed $test An argument. * * @return mixed */ function test($test) { if ($test === TRUE) { return; } return $test; }//end test() /** Comment. * * @return mixed * */ function test() { }//end test() /** * Comment. * * @param \other\ns\item $test An argument. * * @return mixed */ function test(\other\ns\item $test) { return $test; }//end test() /** * Comment. * * @param item $test An argument. * * @return mixed */ function test(\other\ns\item $test) { return $test; }//end test() /** * Comment. * * @param \first\ns\item $test An argument. * * @return mixed */ function test(\first\ns\item $test = \second\ns::CONSTANT) { return $test; }//end test() /** * Comment. * * @param \first\item $test An argument. * * @return mixed */ function test(\first\ns\item $test = \second\ns::CONSTANT) { return $test; }//end test() // Closures should be ignored. preg_replace_callback( '~-([a-z])~', function ($match) { return strtoupper($match[1]); }, 'hello-world' ); $callback = function ($bar) use ($foo) { $bar += $foo; }; /** * Comment should end with '*', not '**' before the slash. **/ function test123() { } /** * Cant use resource for type hint. * * @param resource $test An argument. * * @return mixed */ function test($test) { return $test; }//end test() /** * Variable number of args. * * @param string $a1 Comment here. * @param string $a2 Comment here. * @param string $a2,... Comment here. * * @return boolean */ public function variableArgs($a1, $a2) { return true; }//end variableArgs() /** * Contains closure. * * @return void */ public function containsClosure() { function ($e) { return new Event($e); }, }//end containsClosure() /** * 这是一条测试评论. * * @return void */ public function test() { }//end variableArgs() /** * Uses callable. * * @param callable $cb Test parameter. * * @return void */ public function usesCallable(callable $cb) { $cb(); }//end usesCallable() /** * Creates a map of tokens => line numbers for each token. * * @param array $tokens The array of tokens to process. * @param object $tokenizer The tokenizer being used to process this file. * @param string $eolChar The EOL character * to use for splitting strings. * * @return void * @throws Exception If something really bad * happens while doing foo. */ public function foo(array &$tokens, $tokenizer, $eolChar) { }//end foo() /** * Some description. * * @param \Vendor\Package\SomeClass $someclass Some class. * @param \OtherVendor\Package\SomeClass2 $someclass2 Some class. * @param \OtherVendor\Package\SomeClass2 $someclass3 Some class. * * @return void */ public function foo(SomeClass $someclass, \OtherVendor\Package\SomeClass2 $someclass2, SomeClass3 $someclass3) { } /** * Gettext. * * @return string */ public function _() { return $foo; } class Baz { /** * The PHP5 constructor * * No return tag */ public function __construct() { } } /** * Test * * @return void * @throws E */ function myFunction() {} /** * Yield test * * @return integer */ function yieldTest() { for ($i = 0; $i < 5; $i++) { yield $i; } } /** * Yield test * * @return void */ function yieldTest() { for ($i = 0; $i < 5; $i++) { yield $i; } } /** * Using "array" as a type hint should satisfy a specified array parameter type. * * @param MyClass[] $values An array of MyClass objects. * * @return void */ public function specifiedArray(array $values) { }// end specifiedArray() /** * Using "callable" as a type hint should satisfy a "callback" parameter type. * * @param callback $cb A callback. * * @return void */ public function callableCallback(callable $cb) { }// end callableCallback() /** * PHP7 type hints. * * @param string $name1 Comment. * @param integer $name2 Comment. * @param float $name3 Comment. * @param boolean $name4 Comment. * * @return void */ public function myFunction (string $name1, int $name2, float $name3, bool $name4) { } /** * Variadic function. * * @param string $name1 Comment. * @param string ...$name2 Comment. * * @return void */ public function myFunction(string $name1, string ...$name2) { } /** * Variadic function. * * @param string $name1 Comment. * @param string $name2 Comment. * * @return void */ public function myFunction(string $name1, string ...$name2) { } /** * Return description function + correct type. * * @return integer This is a description. */ public function myFunction() { return 5; } /** * Return description function + incorrect type. * * @return int This is a description. */ public function myFunction() { return 5; } /** * Return description function + no return. * * @return void This is a description. */ public function myFunction() { } /** * Return description function + mixed return. * * @return mixed This is a description. */ public function myFunction() { } /** * Function comment. * * @param $bar * Comment here. * @param ... * Additional arguments here. * * @return * Return value * */ function foo($bar) { } /** * Do something. * * @return void */ public function someFunc(): void { $class = new class { /** * Do something. * * @return string */ public function getString(): string { return 'some string'; } }; } /** * Return description function + mixed return types. * * @return bool|int This is a description. */ function returnTypeWithDescriptionA() { return 5; }//end returnTypeWithDescriptionA() /** * Return description function + mixed return types. * * @return real|bool This is a description. */ function returnTypeWithDescriptionB() { return 5; }//end returnTypeWithDescriptionB() /** * Return description function + lots of different mixed return types. * * @return int|object|string[]|real|double|float|bool|array(int=>MyClass)|callable And here we have a description */ function returnTypeWithDescriptionC() { return 5; }//end returnTypeWithDescriptionC() /** * Return description function + lots of different mixed return types. * * @return array(int=>bool)|\OtherVendor\Package\SomeClass2|MyClass[]|void And here we have a description */ function returnTypeWithDescriptionD() { }//end returnTypeWithDescriptionD() /** * Yield from test * * @return int[] */ function yieldFromTest() { yield from foo(); } /** * Audio * * Generates an audio element to embed sounds * * @param mixed $src Either a source string or * an array of sources. * @param mixed $unsupportedMessage The message to display * if the media tag is not supported by the browser. * @param mixed $attributes HTML attributes. * @return string */ function audio( $src, $unsupportedMessage = '', $attributes = '', ) { return 'test'; } /** * Test function * * @return array */ function returnArrayWithClosure() { function () { return; }; return []; } /** * Test function * * @return array */ function returnArrayWithAnonymousClass() { new class { /** * @return void */ public function test() { return; } }; return []; } /** * @return void */ function returnVoidWithClosure() { function () { return 1; }; } /** * @return void */ function returnVoidWithAnonymousClass() { new class { /** * @return integer */ public function test() { return 1; } }; } class TestReturnVoid { /** * @return void */ public function test() { function () { return 4; }; } } /** * Comment here. * * @param integer $a This is A. * @param ?array $b This is B. * * @return void */ public static function foo(?int $a, ?array $b) {} /** * Comment here. * * @param object $a This is A. * @param object $b This is B. * * @return void */ public function foo(object $a, ?object $b) {} /** * Prepares given PHP class method for later code building. * * @param integer $foo Comment. * - Additional comment. * * @return void */ function foo($foo) {} PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/FunctionCommentUnitTest.inc.fixed0000644000076500000240000003713513614652362031756 0ustar gsherwoodstaff MyClass) */ public function caseSensitive($a1, $a2, $a3, arRay $a4, $a5, $a6, myclas $a7) { }//end caseSensitive() /** * More type hint check for custom type and array. * * @param array $a1 Comment here. * @param array $a2 Comment here. * @param MyClass $a3 Comment here. * @param MyClass $a4 Comment here. * * @return array(integer => MyClass) */ public function typeHint(MyClass $a1, $a2, myclass $a3, $a4) { return (3 => 'myclass obj'); }//end typeHint() /** * Mixed variable type separated by a '|'. * * @param array|string $a1 Comment here. * @param mixed $a2 Comment here. * @param string|array $a3 Comment here. * @param MyClass|integer $a4 Comment here. * * @return boolean */ public function mixedType($a1, $a2, $a3, $a4) { return true; }//end mixedType() /** * Array type. * * @param array(MyClass) $a1 OK. * @param array $a2 Invalid type. * @param array $a3 Typo. * @param array(integer) $a4 Use 'array(integer)' instead. * @param array(integer => integer) $a5 Use 'array(integer => integer)' instead. * @param array(integer => boolean) $a6 Use 'array(integer => boolean)' instead. * @param array $a7 Use 'array' instead. * @param string $a8 String with unknown type hint. * * @return integer */ public function mixedArrayType($a1, $a2, array $a3, $a4, $a5, $a6, $a7, unknownTypeHint $a8) { return 1; }//end mixedArrayType() /** */ function empty1() { }//end empty1() /** * */ function empty2() { }//end empty2() /** * * * */ function empty3() { }//end empty3 /** * @return boolean */ public function missingShortDescriptionInFunctionComment() { return true; }//end missingShortDescriptionInFunctionComment() class Another_Class { /** * Destructor should not include a return tag. * * @return void */ function __destruct() { return; } /** * Constructor should not include a return tag. * * @return void */ function __construct() { return; } }//end class /** * Comment param alignment test. * * @param string $varrr1 Comment1.. * @param string $vr2 Comment2. * @param string $var3 Comment3.. * * @return void */ public static function paramAlign($varrr1, $vr2, $var3) { }//end paramAlign() /** * Comment. * * @param string $id Comment. * @param array $design Comment. * * @return void */ public static function paint($id, array $design) { }//end paint() /** * Adds specified class name to class attribute of this widget. * * @since 4.0.0 * @return string */ public function myFunction() { if ($condition === FALSE) { echo 'hi'; } }//end myFunction() /** * Adds specified class name to class attribute of this widget. * * @return string */ public function myFunction() { if ($condition === FALSE) { echo 'hi'; return; } return 'blah'; }//end myFunction() /** * Adds specified class name to class attribute of this widget. * * @return string */ public function myFunction() { if ($condition === FALSE) { echo 'hi'; } return 'blah'; }//end myFunction() /** * Test function. * * @param string $arg1 An argument * * @access public * @return bool */ echo $blah; function myFunction($arg1) {} class MyClass() { /** * An abstract function. * * @return string[] */ abstract final protected function myFunction(); } /** * Comment. * * @param mixed $test An argument. * * @return mixed */ function test($test) { if ($test === TRUE) { return; } return $test; }//end test() /** Comment. * * @return mixed * */ function test() { }//end test() /** * Comment. * * @param \other\ns\item $test An argument. * * @return mixed */ function test(\other\ns\item $test) { return $test; }//end test() /** * Comment. * * @param item $test An argument. * * @return mixed */ function test(\other\ns\item $test) { return $test; }//end test() /** * Comment. * * @param \first\ns\item $test An argument. * * @return mixed */ function test(\first\ns\item $test = \second\ns::CONSTANT) { return $test; }//end test() /** * Comment. * * @param \first\item $test An argument. * * @return mixed */ function test(\first\ns\item $test = \second\ns::CONSTANT) { return $test; }//end test() // Closures should be ignored. preg_replace_callback( '~-([a-z])~', function ($match) { return strtoupper($match[1]); }, 'hello-world' ); $callback = function ($bar) use ($foo) { $bar += $foo; }; /** * Comment should end with '*', not '**' before the slash. **/ function test123() { } /** * Cant use resource for type hint. * * @param resource $test An argument. * * @return mixed */ function test($test) { return $test; }//end test() /** * Variable number of args. * * @param string $a1 Comment here. * @param string $a2 Comment here. * @param string $a2,... Comment here. * * @return boolean */ public function variableArgs($a1, $a2) { return true; }//end variableArgs() /** * Contains closure. * * @return void */ public function containsClosure() { function ($e) { return new Event($e); }, }//end containsClosure() /** * 这是一条测试评论. * * @return void */ public function test() { }//end variableArgs() /** * Uses callable. * * @param callable $cb Test parameter. * * @return void */ public function usesCallable(callable $cb) { $cb(); }//end usesCallable() /** * Creates a map of tokens => line numbers for each token. * * @param array $tokens The array of tokens to process. * @param object $tokenizer The tokenizer being used to process this file. * @param string $eolChar The EOL character * to use for splitting strings. * * @return void * @throws Exception If something really bad * happens while doing foo. */ public function foo(array &$tokens, $tokenizer, $eolChar) { }//end foo() /** * Some description. * * @param \Vendor\Package\SomeClass $someclass Some class. * @param \OtherVendor\Package\SomeClass2 $someclass2 Some class. * @param \OtherVendor\Package\SomeClass2 $someclass3 Some class. * * @return void */ public function foo(SomeClass $someclass, \OtherVendor\Package\SomeClass2 $someclass2, SomeClass3 $someclass3) { } /** * Gettext. * * @return string */ public function _() { return $foo; } class Baz { /** * The PHP5 constructor * * No return tag */ public function __construct() { } } /** * Test * * @return void * @throws E */ function myFunction() {} /** * Yield test * * @return integer */ function yieldTest() { for ($i = 0; $i < 5; $i++) { yield $i; } } /** * Yield test * * @return void */ function yieldTest() { for ($i = 0; $i < 5; $i++) { yield $i; } } /** * Using "array" as a type hint should satisfy a specified array parameter type. * * @param MyClass[] $values An array of MyClass objects. * * @return void */ public function specifiedArray(array $values) { }// end specifiedArray() /** * Using "callable" as a type hint should satisfy a "callback" parameter type. * * @param callback $cb A callback. * * @return void */ public function callableCallback(callable $cb) { }// end callableCallback() /** * PHP7 type hints. * * @param string $name1 Comment. * @param integer $name2 Comment. * @param float $name3 Comment. * @param boolean $name4 Comment. * * @return void */ public function myFunction (string $name1, int $name2, float $name3, bool $name4) { } /** * Variadic function. * * @param string $name1 Comment. * @param string ...$name2 Comment. * * @return void */ public function myFunction(string $name1, string ...$name2) { } /** * Variadic function. * * @param string $name1 Comment. * @param string $name2 Comment. * * @return void */ public function myFunction(string $name1, string ...$name2) { } /** * Return description function + correct type. * * @return integer This is a description. */ public function myFunction() { return 5; } /** * Return description function + incorrect type. * * @return integer This is a description. */ public function myFunction() { return 5; } /** * Return description function + no return. * * @return void This is a description. */ public function myFunction() { } /** * Return description function + mixed return. * * @return mixed This is a description. */ public function myFunction() { } /** * Function comment. * * @param $bar * Comment here. * @param ... * Additional arguments here. * * @return * Return value * */ function foo($bar) { } /** * Do something. * * @return void */ public function someFunc(): void { $class = new class { /** * Do something. * * @return string */ public function getString(): string { return 'some string'; } }; } /** * Return description function + mixed return types. * * @return boolean|integer This is a description. */ function returnTypeWithDescriptionA() { return 5; }//end returnTypeWithDescriptionA() /** * Return description function + mixed return types. * * @return float|boolean This is a description. */ function returnTypeWithDescriptionB() { return 5; }//end returnTypeWithDescriptionB() /** * Return description function + lots of different mixed return types. * * @return integer|object|string[]|float|boolean|array(integer => MyClass)|callable And here we have a description */ function returnTypeWithDescriptionC() { return 5; }//end returnTypeWithDescriptionC() /** * Return description function + lots of different mixed return types. * * @return array(integer => boolean)|\OtherVendor\Package\SomeClass2|MyClass[]|void And here we have a description */ function returnTypeWithDescriptionD() { }//end returnTypeWithDescriptionD() /** * Yield from test * * @return int[] */ function yieldFromTest() { yield from foo(); } /** * Audio * * Generates an audio element to embed sounds * * @param mixed $src Either a source string or * an array of sources. * @param mixed $unsupportedMessage The message to display * if the media tag is not supported by the browser. * @param mixed $attributes HTML attributes. * @return string */ function audio( $src, $unsupportedMessage = '', $attributes = '', ) { return 'test'; } /** * Test function * * @return array */ function returnArrayWithClosure() { function () { return; }; return []; } /** * Test function * * @return array */ function returnArrayWithAnonymousClass() { new class { /** * @return void */ public function test() { return; } }; return []; } /** * @return void */ function returnVoidWithClosure() { function () { return 1; }; } /** * @return void */ function returnVoidWithAnonymousClass() { new class { /** * @return integer */ public function test() { return 1; } }; } class TestReturnVoid { /** * @return void */ public function test() { function () { return 4; }; } } /** * Comment here. * * @param integer $a This is A. * @param array $b This is B. * * @return void */ public static function foo(?int $a, ?array $b) {} /** * Comment here. * * @param object $a This is A. * @param object $b This is B. * * @return void */ public function foo(object $a, ?object $b) {} /** * Prepares given PHP class method for later code building. * * @param integer $foo Comment. * - Additional comment. * * @return void */ function foo($foo) {} PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/FunctionCommentUnitTest.php0000644000076500000240000000751013614652362030670 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Commenting; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class FunctionCommentUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { $errors = [ 5 => 1, 10 => 3, 12 => 2, 13 => 2, 14 => 1, 15 => 1, 28 => 1, 43 => 1, 76 => 1, 87 => 1, 103 => 1, 109 => 1, 112 => 1, 122 => 1, 123 => 3, 124 => 2, 125 => 1, 126 => 1, 137 => 4, 138 => 4, 139 => 4, 143 => 2, 152 => 1, 155 => 2, 159 => 1, 166 => 1, 173 => 1, 183 => 1, 190 => 2, 193 => 2, 196 => 1, 199 => 2, 210 => 1, 211 => 1, 222 => 1, 223 => 1, 224 => 1, 225 => 1, 226 => 1, 227 => 1, 230 => 2, 232 => 2, 246 => 1, 248 => 4, 261 => 1, 263 => 1, 276 => 1, 277 => 1, 278 => 1, 279 => 1, 280 => 1, 281 => 1, 284 => 1, 286 => 7, 294 => 1, 302 => 1, 312 => 1, 358 => 1, 359 => 2, 372 => 1, 373 => 1, 387 => 1, 407 => 1, 441 => 1, 500 => 1, 526 => 1, 548 => 1, 641 => 1, 669 => 1, 688 => 1, 744 => 1, 748 => 1, 767 => 1, 789 => 1, 792 => 1, 794 => 1, 797 => 1, 801 => 1, 828 => 1, 840 => 1, 852 => 1, 864 => 1, 886 => 1, 888 => 1, 890 => 1, 978 => 1, 997 => 1, ]; // Scalar type hints only work from PHP 7 onwards. if (PHP_VERSION_ID >= 70000) { $errors[17] = 3; $errors[128] = 1; $errors[143] = 3; $errors[161] = 2; $errors[201] = 1; $errors[232] = 7; $errors[363] = 3; $errors[377] = 1; $errors[575] = 2; $errors[627] = 1; $errors[1002] = 1; } else { $errors[729] = 4; $errors[740] = 2; $errors[752] = 2; $errors[982] = 1; } // Object type hints only work from PHP 7.2 onwards. if (PHP_VERSION_ID >= 70200) { $errors[627] = 2; } else { $errors[992] = 2; } return $errors; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/InlineCommentUnitTest.inc0000644000076500000240000000446313614652362030307 0ustar gsherwoodstaff One // -> One.One // -> Two /* Here is some inline example code: -> One -> One.One -> Two */ /** * Comment should be ignored in PHP 5.4. * */ trait MyTrait { } $foo = 'foo'; // Var set to foo. echo $foo; // Comment here. echo $foo; /** * Comments about the include */ include_once($blah); // some comment without capital or full stop echo $foo; // An unrelated comment. // An unrelated comment. echo $foo; // some comment without capital or full stop class Foo { // This is fine. /** * Spacing is ignored above. */ function bar(){} } if ($foo) { }//end if // Another comment here. $foo++; if ($foo) { }//end if // another comment here. $foo++; /* * N.B.: The below test line must be the last test in the file. * Testing that a new line after an inline comment when it's the last non-whitespace * token in a file, does *not* throw an error as this would conflict with the common * "new line required at end of file" rule. */ // For this test line having an empty line below it, is fine. PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/InlineCommentUnitTest.inc.fixed0000644000076500000240000000443513614652362031404 0ustar gsherwoodstaff One // -> One.One // -> Two /* Here is some inline example code: -> One -> One.One -> Two */ /** * Comment should be ignored in PHP 5.4. * */ trait MyTrait { } $foo = 'foo'; // Var set to foo. echo $foo; // Comment here. echo $foo; /** * Comments about the include */ include_once($blah); // some comment without capital or full stop echo $foo; // An unrelated comment. // An unrelated comment. echo $foo; // some comment without capital or full stop class Foo { // This is fine. /** * Spacing is ignored above. */ function bar(){} } if ($foo) { }//end if // Another comment here. $foo++; if ($foo) { }//end if // another comment here. $foo++; /* * N.B.: The below test line must be the last test in the file. * Testing that a new line after an inline comment when it's the last non-whitespace * token in a file, does *not* throw an error as this would conflict with the common * "new line required at end of file" rule. */ // For this test line having an empty line below it, is fine. PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/InlineCommentUnitTest.js0000644000076500000240000000372513614652362030152 0ustar gsherwoodstaff// Some content here. var code = 'hello'; // This comment contains # multiple // hash signs (#). code = 'hello'; /** * This is the first line of a function comment. * This is the second line. */ function testFunction() { // Callback methods which are added by external objects. this.callbacks = {}; }//end testFunction() /** * This is the first line of a class comment. * This is the second line. */ myClass.prototype = { /** * This is the first line of a method comment. * This is the second line. */ load: function(url, callback) { // Some code here. } }; // some code goes here! /* A longer comment goes here. It spans multiple lines!! Or does it? */ // 0This is a simple multi-line // comment! code = 'hello'; //This is not valid. code = 'hello'; // Neither is this! code = 'hello'; // code = 'hello'; /** Neither is this! **/ code = 'hello'; /** * This is the first line of a function comment. * This is the second line. */ var myFunction = function() { } /** * This is the first line of a function comment. * This is the second line. */ myFunction = function() { } /** * This is the first line of a function comment. * This is the second line. */ myClass.myFunction = function() { } dfx.getIframeDocument = function(iframe) { return doc; };//end dfx.getIframeDocument() mig.Gallery.prototype = { init: function(cb) { },//end init() imageClicked: function(id) { }//end imageClicked() }; // Here is some inline example code: // -> One // -> One.One // -> Two /* Here is some inline example code: -> One -> One.One -> Two */ var foo = 'foo'; // Var set to foo. console.info(foo); // Comment here. console.info(foo); //** * invalid comment */ // some comment without capital or full stop console.log(foo); // An unrelated comment. // An unrelated comment. console.log(foo); // some comment without capital or full stop PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/InlineCommentUnitTest.js.fixed0000644000076500000240000000370013614652362031241 0ustar gsherwoodstaff// Some content here. var code = 'hello'; // This comment contains # multiple // hash signs (#). code = 'hello'; /** * This is the first line of a function comment. * This is the second line. */ function testFunction() { // Callback methods which are added by external objects. this.callbacks = {}; }//end testFunction() /** * This is the first line of a class comment. * This is the second line. */ myClass.prototype = { /** * This is the first line of a method comment. * This is the second line. */ load: function(url, callback) { // Some code here. } }; // some code goes here! /* A longer comment goes here. It spans multiple lines!! Or does it? */ // 0This is a simple multi-line // comment! code = 'hello'; // This is not valid. code = 'hello'; // Neither is this! code = 'hello'; code = 'hello'; /** Neither is this! **/ code = 'hello'; /** * This is the first line of a function comment. * This is the second line. */ var myFunction = function() { } /** * This is the first line of a function comment. * This is the second line. */ myFunction = function() { } /** * This is the first line of a function comment. * This is the second line. */ myClass.myFunction = function() { } dfx.getIframeDocument = function(iframe) { return doc; };//end dfx.getIframeDocument() mig.Gallery.prototype = { init: function(cb) { },//end init() imageClicked: function(id) { }//end imageClicked() }; // Here is some inline example code: // -> One // -> One.One // -> Two /* Here is some inline example code: -> One -> One.One -> Two */ var foo = 'foo'; // Var set to foo. console.info(foo); // Comment here. console.info(foo); // ** * invalid comment */ // some comment without capital or full stop console.log(foo); // An unrelated comment. // An unrelated comment. console.log(foo); // some comment without capital or full stop PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/InlineCommentUnitTest.php0000644000076500000240000000443313614652362030322 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Commenting; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class InlineCommentUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='InlineCommentUnitTest.inc') { switch ($testFile) { case 'InlineCommentUnitTest.inc': $errors = [ 17 => 1, 27 => 1, 28 => 1, 32 => 2, 36 => 1, 44 => 2, 58 => 1, 61 => 1, 64 => 1, 67 => 1, 95 => 1, 96 => 1, 97 => 3, 118 => 1, 126 => 2, 130 => 2, 149 => 1, ]; return $errors; case 'InlineCommentUnitTest.js': return [ 31 => 1, 36 => 2, 48 => 1, 51 => 1, 54 => 1, 57 => 1, 102 => 1, 103 => 1, 104 => 3, 118 => 1, 121 => 1, 125 => 2, 129 => 2, ]; default: return []; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/LongConditionClosingCommentUnitTest.inc0000644000076500000240000004032113614652362033147 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Commenting; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class LongConditionClosingCommentUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='LongConditionClosingCommentUnitTest.inc') { switch ($testFile) { case 'LongConditionClosingCommentUnitTest.inc': return [ 49 => 1, 99 => 1, 146 => 1, 192 => 1, 215 => 1, 238 => 1, 261 => 1, 286 => 1, 309 => 1, 332 => 1, 355 => 1, 378 => 1, 493 => 1, 531 => 1, 536 => 1, 540 => 1, 562 => 1, 601 => 1, 629 => 1, 663 => 1, 765 => 1, 798 => 1, 811 => 1, 897 => 1, 931 => 1, 962 => 1, ]; break; case 'LongConditionClosingCommentUnitTest.js': return [ 47 => 1, 97 => 1, 144 => 1, 190 => 1, 213 => 1, 238 => 1, 261 => 1, 284 => 1, 307 => 1, 401 => 1, 439 => 1, 444 => 1, ]; break; default: return []; break; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/PostStatementCommentUnitTest.inc0000644000076500000240000000157413614652362031703 0ustar gsherwoodstaff function($b) { }, // comment. 'key' => 'value', // phpcs:ignore Standard.Category.SniffName -- for reasons. 'key' => 'value', // comment. ]; // Verify that multi-line control structure with comments and annotations are left alone. for ( $i = 0; /* Start */ $i < 10; /* phpcs:ignore Standard.Category.SniffName -- for reasons. */ $i++ // comment ) {} if ( $condition === true // comment && $anotherCondition === false ) {} PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/PostStatementCommentUnitTest.inc.fixed0000644000076500000240000000160013614652362032767 0ustar gsherwoodstaff function($b) { }, // comment. 'key' => 'value', // phpcs:ignore Standard.Category.SniffName -- for reasons. 'key' => 'value', // comment. ]; // Verify that multi-line control structure with comments and annotations are left alone. for ( $i = 0; /* Start */ $i < 10; /* phpcs:ignore Standard.Category.SniffName -- for reasons. */ $i++ // comment ) {} if ( $condition === true // comment && $anotherCondition === false ) {} PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/PostStatementCommentUnitTest.1.js0000644000076500000240000000110313614652362031671 0ustar gsherwoodstafffunction test(id, buttons) // cool function { alert('hello'); alert('hello again'); // And again. // Valid comment. }//end test() var good = true; // Indeed. mig.Gallery.prototype = { init: function(cb) { },//end init() imageClicked: function(id) { }//end imageClicked() }; dfx.getIframeDocument = function(iframe) { return doc; };//end dfx.getIframeDocument() // Verify that multi-line control structure with comments and annotations are left alone. if (condition // comment && anotherCondition) { condition = true; } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/PostStatementCommentUnitTest.1.js.fixed0000644000076500000240000000110613614652362032772 0ustar gsherwoodstafffunction test(id, buttons) // cool function { alert('hello'); alert('hello again'); // And again. // Valid comment. }//end test() var good = true; // Indeed. mig.Gallery.prototype = { init: function(cb) { },//end init() imageClicked: function(id) { }//end imageClicked() }; dfx.getIframeDocument = function(iframe) { return doc; };//end dfx.getIframeDocument() // Verify that multi-line control structure with comments and annotations are left alone. if (condition // comment && anotherCondition) { condition = true; } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/PostStatementCommentUnitTest.2.js0000644000076500000240000000006513614652362031700 0ustar gsherwoodstaff// Comment as first thing in a JS file. var i = 100; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/PostStatementCommentUnitTest.php0000644000076500000240000000330213614652362031710 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Commenting; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class PostStatementCommentUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='PostStatementCommentUnitTest.inc') { switch ($testFile) { case 'PostStatementCommentUnitTest.inc': return [ 6 => 1, 10 => 1, 18 => 1, 35 => 1, ]; case 'PostStatementCommentUnitTest.1.js': return [ 1 => 1, 4 => 1, 9 => 1, ]; default: return []; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/VariableCommentUnitTest.inc0000644000076500000240000001310713614652362030611 0ustar gsherwoodstaff $content) { echo $content; } return $var1; }//end checkVariable() /** * * */ $emptyVarDoc = ''; /** * Var type checking (int v.s. integer). * * @var int */ private $_varSimpleTypeCheck; /** * Var type checking (array(int => string) v.s. array(int => string)). * * @var array(int => string) */ private $_varArrayTypeCheck; /** * Boolean @var tag Capitalized * * @var Boolean */ public $CapBoolTag = true; /** * Boolean @var tag Capitalized * * @var BOOLEAN */ public $CapBoolTag2 = true; /** * Double @var tag Capitalized * * @var Double */ public $CapDoubleTag = 1; /** * Double @var tag Capitalized * * @var DOUBLE */ public $CapDoubleTag2 = 1; /** * Real @var tag Capitalized * * @var Real */ public $CapRealTag = 1; /** * Real @var tag Capitalized * * @var REAL */ public $CapRealTag2 = 1; /** * Float @var tag Capitalized * * @var Float */ public $CapFloatTag = 1; /** * Float @var tag Capitalized * * @var FLOAT */ public $CapFloatTag2 = 1; /** * Int @var tag Capitalized * * @var Int */ public $CapIntTag = 1; /** * Int @var tag Capitalized * * @var INT */ public $CapIntTag2 = 1; /** * Integer @var tag Capitalized * * @var Integer */ public $CapIntTag3 = 1; /** * Integer @var tag Capitalized * * @var INTEGER */ public $CapIntTag4 = 1; /** * Array @var tag Capitalized * * @var Array */ public $CapVarTag = []; /** * Array @var tag All Caps * * @var ARRAY */ public $CapVarTag2 = []; /** * Array @var tag Capitalized * * @var Array() */ public $CapVarTag3 = []; /** * Array @var tag All Caps * * @var ARRAY() */ public $CapVarTag4 = []; /** * Var type checking (STRING v.s. string). * * @var STRING */ private $_varCaseTypeCheck; /** * @var integer */ private $_varWithNoShortComment; protected $noComment2 = ''; /** * @var int Var type checking (int v.s. integer) with single-line comment. */ private $_varSimpleTypeCheckSingleLine; }//end class /** * VariableCommentUnitTest2. * * Long description goes here. * */ class VariableCommentUnitTest2 { public $hello; /** Comment starts here. * * @var string * */ private $_varCaseTypeCheck; /** * 这是一条测试评论. * * @var string */ public $foo; }//end class /* * Class comment */ class Foo { protected $bar; /** * Short description of the member variable. * * @var array */ public static array $variableName = array(); } class Foo { /** * Short description of the member variable. * * @var array */ public array $variableName = array(); // Not "/**" style comment. // // @var string private ?Folder\ClassName $_incorrectCommentStyle = null; var int $noComment = 1; } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/VariableCommentUnitTest.inc.fixed0000644000076500000240000001312713614652362031711 0ustar gsherwoodstaff $content) { echo $content; } return $var1; }//end checkVariable() /** * * */ $emptyVarDoc = ''; /** * Var type checking (int v.s. integer). * * @var integer */ private $_varSimpleTypeCheck; /** * Var type checking (array(int => string) v.s. array(int => string)). * * @var array(integer => string) */ private $_varArrayTypeCheck; /** * Boolean @var tag Capitalized * * @var boolean */ public $CapBoolTag = true; /** * Boolean @var tag Capitalized * * @var boolean */ public $CapBoolTag2 = true; /** * Double @var tag Capitalized * * @var float */ public $CapDoubleTag = 1; /** * Double @var tag Capitalized * * @var float */ public $CapDoubleTag2 = 1; /** * Real @var tag Capitalized * * @var float */ public $CapRealTag = 1; /** * Real @var tag Capitalized * * @var float */ public $CapRealTag2 = 1; /** * Float @var tag Capitalized * * @var float */ public $CapFloatTag = 1; /** * Float @var tag Capitalized * * @var float */ public $CapFloatTag2 = 1; /** * Int @var tag Capitalized * * @var integer */ public $CapIntTag = 1; /** * Int @var tag Capitalized * * @var integer */ public $CapIntTag2 = 1; /** * Integer @var tag Capitalized * * @var integer */ public $CapIntTag3 = 1; /** * Integer @var tag Capitalized * * @var integer */ public $CapIntTag4 = 1; /** * Array @var tag Capitalized * * @var array */ public $CapVarTag = []; /** * Array @var tag All Caps * * @var array */ public $CapVarTag2 = []; /** * Array @var tag Capitalized * * @var array */ public $CapVarTag3 = []; /** * Array @var tag All Caps * * @var array */ public $CapVarTag4 = []; /** * Var type checking (STRING v.s. string). * * @var string */ private $_varCaseTypeCheck; /** * @var integer */ private $_varWithNoShortComment; protected $noComment2 = ''; /** * @var integer Var type checking (int v.s. integer) with single-line comment. */ private $_varSimpleTypeCheckSingleLine; }//end class /** * VariableCommentUnitTest2. * * Long description goes here. * */ class VariableCommentUnitTest2 { public $hello; /** Comment starts here. * * @var string * */ private $_varCaseTypeCheck; /** * 这是一条测试评论. * * @var string */ public $foo; }//end class /* * Class comment */ class Foo { protected $bar; /** * Short description of the member variable. * * @var array */ public static array $variableName = array(); } class Foo { /** * Short description of the member variable. * * @var array */ public array $variableName = array(); // Not "/**" style comment. // // @var string private ?Folder\ClassName $_incorrectCommentStyle = null; var int $noComment = 1; } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Commenting/VariableCommentUnitTest.php0000644000076500000240000000356213614652362030633 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Commenting; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class VariableCommentUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 21 => 1, 24 => 1, 56 => 1, 64 => 1, 73 => 1, 84 => 1, 130 => 1, 136 => 1, 144 => 1, 152 => 1, 160 => 1, 168 => 1, 176 => 1, 184 => 1, 192 => 1, 200 => 1, 208 => 1, 216 => 1, 224 => 1, 232 => 1, 240 => 1, 248 => 1, 256 => 1, 264 => 1, 272 => 1, 280 => 1, 290 => 1, 294 => 1, 311 => 1, 336 => 1, 361 => 1, 364 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return [93 => 1]; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/ControlStructures/ControlSignatureUnitTest.inc0000644000076500000240000000762613614652362032500 0ustar gsherwoodstaff 0); do { echo $i; } while ($i > 0); do { echo $i; } while ($i > 0); do { echo $i; } while ($i > 0); do{ echo $i; }while($i > 0); while ($i < 1) { echo $i; } while($i < 1){ echo $i; } while ($i < 1) { echo $i; } for ($i = 1; $i < 1; $i++) { echo $i; } for($i = 1; $i < 1; $i++){ echo $i; } for ($i = 1; $i < 1; $i++) { echo $i; } if ($i == 0) { $i = 1; } if($i == 0){ $i = 1; } if ($i == 0) { $i = 1; } if ($i == 0) { $i = 1; } else { $i = 0; } if ($i == 0) { $i = 1; }else{ $i = 0; } if ($i == 0) { $i = 1; } else { $i = 0; } if ($i == 0) { $i = 1; } else if ($i == 2) { $i = 0; } if ($i == 0) { $i = 1; }else if($i == 2){ $i = 0; } if ($i == 0) { $i = 1; } else if ($i == 2) { $i = 0; } if ($i == 0) { // comments are allowed $i = 1; } if ($i == 0) {// comments are allowed $i = 1; } if ($i == 0) { /* comments are allowed*/ $i = 1; } if ($i == 0) { // this is ok $i = 1; } if ($i == 0) /* this is ok */ { } try { $code = 'this'; } catch (Exception $e) { // Caught! } try { $code = 'this'; } catch (Exception $e) { // Caught! } do { echo $i; } while ($i > 0); if ($i === 0) { $i = 1 } if ($a) { } elseif ($b) { } foreach ($items as $item) { echo $item; } foreach($items as $item){ echo $item; } if ($a && $b) // && $c) { } if ($a == 5) : echo "a equals 5"; echo "..."; elseif ($a == 6) : echo "a equals 6"; echo "!!!"; else : echo "a is neither 5 nor 6"; endif; try { // try body } catch (FirstExceptionType $e) { // catch body } catch (OtherExceptionType $e) { // catch body } switch($foo) { case 'bar': break; } if ($foo) : endif; ?> getRow()): ?>

    hello hello getRow()) : ?>

    hello hello 0); do { echo $i; } while ($i > 0); do { echo $i; } while ($i > 0); do { echo $i; } while ($i > 0); do { echo $i; } while ($i > 0); while ($i < 1) { echo $i; } while ($i < 1) { echo $i; } while ($i < 1) { echo $i; } for ($i = 1; $i < 1; $i++) { echo $i; } for ($i = 1; $i < 1; $i++) { echo $i; } for ($i = 1; $i < 1; $i++) { echo $i; } if ($i == 0) { $i = 1; } if ($i == 0) { $i = 1; } if ($i == 0) { $i = 1; } if ($i == 0) { $i = 1; } else { $i = 0; } if ($i == 0) { $i = 1; } else { $i = 0; } if ($i == 0) { $i = 1; } else { $i = 0; } if ($i == 0) { $i = 1; } else if ($i == 2) { $i = 0; } if ($i == 0) { $i = 1; } else if ($i == 2) { $i = 0; } if ($i == 0) { $i = 1; } else if ($i == 2) { $i = 0; } if ($i == 0) { // comments are allowed $i = 1; } if ($i == 0) {// comments are allowed $i = 1; } if ($i == 0) { /* comments are allowed*/ $i = 1; } if ($i == 0) { // this is ok $i = 1; } if ($i == 0) { /* this is ok */ } try { $code = 'this'; } catch (Exception $e) { // Caught! } try { $code = 'this'; } catch (Exception $e) { // Caught! } do { echo $i; } while ($i > 0); if ($i === 0) { $i = 1 } if ($a) { } elseif ($b) { } foreach ($items as $item) { echo $item; } foreach ($items as $item) { echo $item; } if ($a && $b) { // && $c) } if ($a == 5) : echo "a equals 5"; echo "..."; elseif ($a == 6) : echo "a equals 6"; echo "!!!"; else : echo "a is neither 5 nor 6"; endif; try { // try body } catch (FirstExceptionType $e) { // catch body } catch (OtherExceptionType $e) { // catch body } switch ($foo) { case 'bar': break; } if ($foo) : endif; ?> getRow()) : ?>

    hello hello getRow()): ?>

    hello hello 0); do { i = 0; } while (i > 0); do { i = 0; } while (i > 0); do { i = 0; } while (i > 0); do{ i = 0; }while(i > 0); while (i < 1) { i = 0; } while(i < 1){ i = 0; } while (i < 1) { i = 0; } for (i = 1; i < 1; i++) { i = 0; } for(i = 1; i < 1; i++){ i = 0; } for (i = 1; i < 1; i++) { i = 0; } if (i == 0) { i = 1; } if(i == 0){ i = 1; } if (i == 0) { i = 1; } if (i == 0) { i = 1; } else { i = 0; } if (i == 0) { i = 1; }else{ i = 0; } if (i == 0) { i = 1; } else { i = 0; } if (i == 0) { i = 1; } else if (i == 2) { i = 0; } if (i == 0) { i = 1; }else if(i == 2){ i = 0; } if (i == 0) { i = 1; } else if (i == 2) { i = 0; } if (i == 0) { // comments are allowed i = 1; } if (i == 0) {// comments are allowed i = 1; } if (i == 0) { /* comments are allowed*/ i = 1; } if (i == 0) { // this is ok i = 1; } if (i == 0) /* this is ok */ { } try { code = 'this'; } catch (e) { // Caught! } try { code = 'this'; } catch (e) { // Caught! } do { i = 0; } while (i > 0); if (i === 0) { i = 1 } if (window.jQuery)(function($) { $.fn.reset = function() { return this.each(function() { try { this.reset(); } catch (e) { } }); }; })(jQuery); if ($("#myid").rotationDegrees()=='90') $('.modal').css({'transform': 'rotate(90deg)'}); if ($("#myid").rotationDegrees()=='90') $foo = {'transform': 'rotate(90deg)'}; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/ControlStructures/ControlSignatureUnitTest.js.fixed0000644000076500000240000000303513614652362033427 0ustar gsherwoodstaff i = 0; do { i = 0; } while (i > 0); do { i = 0; } while (i > 0); do { i = 0; } while (i > 0); do { i = 0; } while (i > 0); do { i = 0; } while (i > 0); while (i < 1) { i = 0; } while (i < 1) { i = 0; } while (i < 1) { i = 0; } for (i = 1; i < 1; i++) { i = 0; } for (i = 1; i < 1; i++) { i = 0; } for (i = 1; i < 1; i++) { i = 0; } if (i == 0) { i = 1; } if (i == 0) { i = 1; } if (i == 0) { i = 1; } if (i == 0) { i = 1; } else { i = 0; } if (i == 0) { i = 1; } else { i = 0; } if (i == 0) { i = 1; } else { i = 0; } if (i == 0) { i = 1; } else if (i == 2) { i = 0; } if (i == 0) { i = 1; } else if (i == 2) { i = 0; } if (i == 0) { i = 1; } else if (i == 2) { i = 0; } if (i == 0) { // comments are allowed i = 1; } if (i == 0) {// comments are allowed i = 1; } if (i == 0) { /* comments are allowed*/ i = 1; } if (i == 0) { // this is ok i = 1; } if (i == 0) { /* this is ok */ } try { code = 'this'; } catch (e) { // Caught! } try { code = 'this'; } catch (e) { // Caught! } do { i = 0; } while (i > 0); if (i === 0) { i = 1 } if (window.jQuery)(function($) { $.fn.reset = function() { return this.each(function() { try { this.reset(); } catch (e) { } }); }; })(jQuery); if ($("#myid").rotationDegrees()=='90') $('.modal').css({'transform': 'rotate(90deg)'}); if ($("#myid").rotationDegrees()=='90') $foo = {'transform': 'rotate(90deg)'}; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/ControlStructures/ControlSignatureUnitTest.php0000644000076500000240000000506613614652362032512 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\ControlStructures; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ControlSignatureUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='ControlSignatureUnitTest.inc') { $errors = [ 7 => 1, 12 => 1, 15 => 1, 18 => 1, 20 => 1, 22 => 2, 28 => 2, 32 => 1, 38 => 2, 42 => 1, 48 => 2, 52 => 1, 62 => 2, 66 => 2, 76 => 4, 80 => 2, 94 => 1, 99 => 1, 108 => 1, 112 => 1, ]; if ($testFile === 'ControlSignatureUnitTest.inc') { $errors[122] = 1; $errors[130] = 2; $errors[134] = 1; $errors[150] = 1; $errors[153] = 1; $errors[158] = 1; $errors[165] = 1; $errors[170] = 2; $errors[185] = 1; $errors[190] = 2; $errors[191] = 2; $errors[195] = 1; $errors[227] = 1; $errors[234] = 1; $errors[239] = 2; $errors[243] = 2; $errors[244] = 2; $errors[248] = 1; $errors[259] = 1; $errors[262] = 1; $errors[267] = 1; $errors[269] = 1; $errors[276] = 1; $errors[279] = 1; $errors[283] = 1; }//end if return $errors; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/ControlStructures/ElseIfDeclarationUnitTest.inc0000644000076500000240000000026113614652362032477 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\ControlStructures; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ElseIfDeclarationUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 8 => 1, 13 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class ././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/ControlStructures/ForEachLoopDeclarationUnitTest.incPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/ControlStructures/ForEachLoopDeclarationUnitTest.inc0000644000076500000240000000162213614652362033473 0ustar gsherwoodstaff $that) { } // Invalid. foreach ( $something as $blah => $that ) { } foreach ($something as $blah => $that) { } foreach ($something as $blah => $that) { } foreach (${something}AS$blah=>$that) { } // The works. foreach ( $something aS $blah => $that ) { } // phpcs:set Squiz.ControlStructures.ForEachLoopDeclaration requiredSpacesAfterOpen 1 // phpcs:set Squiz.ControlStructures.ForEachLoopDeclaration requiredSpacesBeforeClose 1 foreach ($something as $blah => $that) {} foreach ( $something as $blah => $that ) {} foreach ( $something as $blah => $that ) {} // phpcs:set Squiz.ControlStructures.ForEachLoopDeclaration requiredSpacesAfterOpen 0 // phpcs:set Squiz.ControlStructures.ForEachLoopDeclaration requiredSpacesBeforeClose 0 foreach ([ 'foo' => 'bar', 'foobaz' => 'bazzy', ] as $key => $value) { } ././@LongLink0000000000000000000000000000015200000000000007753 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/ControlStructures/ForEachLoopDeclarationUnitTest.inc.fixedPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/ControlStructures/ForEachLoopDeclarationUnitTest.inc0000644000076500000240000000157713614652362033504 0ustar gsherwoodstaff $that) { } // Invalid. foreach ($something as $blah => $that) { } foreach ($something as $blah => $that) { } foreach ($something as $blah => $that) { } foreach (${something} as $blah => $that) { } // The works. foreach ($something as $blah => $that) { } // phpcs:set Squiz.ControlStructures.ForEachLoopDeclaration requiredSpacesAfterOpen 1 // phpcs:set Squiz.ControlStructures.ForEachLoopDeclaration requiredSpacesBeforeClose 1 foreach ( $something as $blah => $that ) {} foreach ( $something as $blah => $that ) {} foreach ( $something as $blah => $that ) {} // phpcs:set Squiz.ControlStructures.ForEachLoopDeclaration requiredSpacesAfterOpen 0 // phpcs:set Squiz.ControlStructures.ForEachLoopDeclaration requiredSpacesBeforeClose 0 foreach ([ 'foo' => 'bar', 'foobaz' => 'bazzy', ] as $key => $value) { } ././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/ControlStructures/ForEachLoopDeclarationUnitTest.phpPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/ControlStructures/ForEachLoopDeclarationUnitTest.php0000644000076500000240000000252313614652362033512 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\ControlStructures; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ForEachLoopDeclarationUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 8 => 2, 11 => 2, 14 => 2, 17 => 5, 21 => 7, 26 => 2, 28 => 2, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/ControlStructures/ForLoopDeclarationUnitTest.inc0000644000076500000240000000555713614652362032725 0ustar gsherwoodstaffi ; }; $i < function() { return $this->max; }; $i++) {} for ($i = function() { return $this->i; }; $i < function() { return $this->max; } ; $i++) {} // phpcs:set Squiz.ControlStructures.ForLoopDeclaration ignoreNewlines true for ( $i = 0; $i < 5; $i++ ) { // body here } // phpcs:set Squiz.ControlStructures.ForLoopDeclaration ignoreNewlines false // This test has to be the last one in the file! Intentional parse error check. for ././@LongLink0000000000000000000000000000014600000000000007756 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/ControlStructures/ForLoopDeclarationUnitTest.inc.fixedPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/ControlStructures/ForLoopDeclarationUnitTest.inc.fix0000644000076500000240000000532713614652362033505 0ustar gsherwoodstaffi ; }; $i < function() { return $this->max; }; $i++) {} for ($i = function() { return $this->i; }; $i < function() { return $this->max; }; $i++) {} // phpcs:set Squiz.ControlStructures.ForLoopDeclaration ignoreNewlines true for ( $i = 0; $i < 5; $i++ ) { // body here } // phpcs:set Squiz.ControlStructures.ForLoopDeclaration ignoreNewlines false // This test has to be the last one in the file! Intentional parse error check. for PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/ControlStructures/ForLoopDeclarationUnitTest.js0000644000076500000240000000571713614652362032566 0ustar gsherwoodstaff// Valid. for (var i = 0; i < 10; i++) { } // Invalid. for ( i = 0; i < 10; i++ ) { } for (i = 0; i < 10; i++) { } for (var i = 0 ; i < 10 ; i++) { } for (i = 0;i < 10;i++) { } // The works. for ( var i = 0 ; i < 10 ; i++ ) { } this.formats = {}; dfx.inherits('ContentFormat', 'Widget'); for (var widgetid in this.loadedContents) { if (dfx.isset(widget) === true) { widget.loadAutoSaveCWidgetStore.setData('activeScreen', null);widget.getContents(this.loadedContents[widgetid], function() {self.widgetLoaded(widget.id);}); } } for (var i = 0; i < 10;) { } for (var i = 0; i < 10; ) { } for (var i = 0; ; i++) { } for (var i = 0;; i++) { } // phpcs:set Squiz.ControlStructures.ForLoopDeclaration requiredSpacesAfterOpen 1 // phpcs:set Squiz.ControlStructures.ForLoopDeclaration requiredSpacesBeforeClose 1 for (var i = 0; i < 10; i++) {} for ( var i = 0; i < 10; i++ ) {} for ( var i = 0; i < 10; i++ ) {} // phpcs:set Squiz.ControlStructures.ForLoopDeclaration requiredSpacesAfterOpen 0 // phpcs:set Squiz.ControlStructures.ForLoopDeclaration requiredSpacesBeforeClose 0 for ( ; i < 10; i++) {} for (; i < 10; i++) {} // phpcs:set Squiz.ControlStructures.ForLoopDeclaration requiredSpacesAfterOpen 1 // phpcs:set Squiz.ControlStructures.ForLoopDeclaration requiredSpacesBeforeClose 1 for ( ; i < 10; i++ ) {} for ( ; i < 10; i++ ) {} for (; i < 10; i++ ) {} for ( i = 0; i < 10; ) {} for ( i = 0; i < 10;) {} for ( i = 0; i < 10; ) {} // phpcs:set Squiz.ControlStructures.ForLoopDeclaration requiredSpacesAfterOpen 0 // phpcs:set Squiz.ControlStructures.ForLoopDeclaration requiredSpacesBeforeClose 0 // Test handling of comments and inline annotations. for ( /*phpcs:enable*/ i = 0 /*start*/ ; /*end*/i < 10/*comment*/; i++ /*comment*/ ) {} // Test multi-line FOR control structure. for ( i = 0; i < 10; i++ ) {} // Test multi-line FOR control structure with comments and annotations. for ( i = 0; /* Start */ i < 10; /* phpcs:ignore Standard.Category.SniffName -- for reasons. */ i++ // comment ) {} // Test fixing each error in one go. Note: lines 84 + 88 contain trailing whitespace on purpose. for ( i = 0 ; i < 10 ; i++ ) {} // phpcs:set Squiz.ControlStructures.ForLoopDeclaration requiredSpacesAfterOpen 1 // phpcs:set Squiz.ControlStructures.ForLoopDeclaration requiredSpacesBeforeClose 1 for ( i = 0 ; i < 10 ; i++ ) {} // phpcs:set Squiz.ControlStructures.ForLoopDeclaration requiredSpacesAfterOpen 0 // phpcs:set Squiz.ControlStructures.ForLoopDeclaration requiredSpacesBeforeClose 0 // Test with semi-colon not belonging to for. for (i = function() {self.widgetLoaded(widget.id) ; }; i < function() {self.widgetLoaded(widget.id);}; i++) {} for (i = function() {self.widgetLoaded(widget.id);}; i < function() {self.widgetLoaded(widget.id);} ; i++) {} // This test has to be the last one in the file! Intentional parse error check. for ././@LongLink0000000000000000000000000000014500000000000007755 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/ControlStructures/ForLoopDeclarationUnitTest.js.fixedPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/ControlStructures/ForLoopDeclarationUnitTest.js.fixe0000644000076500000240000000547313614652362033517 0ustar gsherwoodstaff// Valid. for (var i = 0; i < 10; i++) { } // Invalid. for (i = 0; i < 10; i++) { } for (i = 0; i < 10; i++) { } for (var i = 0; i < 10; i++) { } for (i = 0; i < 10; i++) { } // The works. for (var i = 0; i < 10; i++) { } this.formats = {}; dfx.inherits('ContentFormat', 'Widget'); for (var widgetid in this.loadedContents) { if (dfx.isset(widget) === true) { widget.loadAutoSaveCWidgetStore.setData('activeScreen', null);widget.getContents(this.loadedContents[widgetid], function() {self.widgetLoaded(widget.id);}); } } for (var i = 0; i < 10;) { } for (var i = 0; i < 10;) { } for (var i = 0;; i++) { } for (var i = 0;; i++) { } // phpcs:set Squiz.ControlStructures.ForLoopDeclaration requiredSpacesAfterOpen 1 // phpcs:set Squiz.ControlStructures.ForLoopDeclaration requiredSpacesBeforeClose 1 for ( var i = 0; i < 10; i++ ) {} for ( var i = 0; i < 10; i++ ) {} for ( var i = 0; i < 10; i++ ) {} // phpcs:set Squiz.ControlStructures.ForLoopDeclaration requiredSpacesAfterOpen 0 // phpcs:set Squiz.ControlStructures.ForLoopDeclaration requiredSpacesBeforeClose 0 for (; i < 10; i++) {} for (; i < 10; i++) {} // phpcs:set Squiz.ControlStructures.ForLoopDeclaration requiredSpacesAfterOpen 1 // phpcs:set Squiz.ControlStructures.ForLoopDeclaration requiredSpacesBeforeClose 1 for ( ; i < 10; i++ ) {} for ( ; i < 10; i++ ) {} for ( ; i < 10; i++ ) {} for ( i = 0; i < 10; ) {} for ( i = 0; i < 10; ) {} for ( i = 0; i < 10; ) {} // phpcs:set Squiz.ControlStructures.ForLoopDeclaration requiredSpacesAfterOpen 0 // phpcs:set Squiz.ControlStructures.ForLoopDeclaration requiredSpacesBeforeClose 0 // Test handling of comments and inline annotations. for (/*phpcs:enable*/ i = 0 /*start*/; /*end*/i < 10/*comment*/; i++ /*comment*/) {} // Test multi-line FOR control structure. for (i = 0; i < 10; i++) {} // Test multi-line FOR control structure with comments and annotations. for (i = 0; /* Start */ i < 10; /* phpcs:ignore Standard.Category.SniffName -- for reasons. */ i++ // comment ) {} // Test fixing each error in one go. Note: lines 84 + 88 contain trailing whitespace on purpose. for (i = 0; i < 10; i++) {} // phpcs:set Squiz.ControlStructures.ForLoopDeclaration requiredSpacesAfterOpen 1 // phpcs:set Squiz.ControlStructures.ForLoopDeclaration requiredSpacesBeforeClose 1 for ( i = 0; i < 10; i++ ) {} // phpcs:set Squiz.ControlStructures.ForLoopDeclaration requiredSpacesAfterOpen 0 // phpcs:set Squiz.ControlStructures.ForLoopDeclaration requiredSpacesBeforeClose 0 // Test with semi-colon not belonging to for. for (i = function() {self.widgetLoaded(widget.id) ; }; i < function() {self.widgetLoaded(widget.id);}; i++) {} for (i = function() {self.widgetLoaded(widget.id);}; i < function() {self.widgetLoaded(widget.id);}; i++) {} // This test has to be the last one in the file! Intentional parse error check. for PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/ControlStructures/ForLoopDeclarationUnitTest.php0000644000076500000240000000660113614652362032732 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\ControlStructures; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ForLoopDeclarationUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='ForLoopDeclarationUnitTest.inc') { switch ($testFile) { case 'ForLoopDeclarationUnitTest.inc': return [ 8 => 2, 11 => 2, 14 => 2, 17 => 2, 21 => 6, 27 => 1, 30 => 1, 37 => 2, 39 => 2, 43 => 1, 49 => 1, 50 => 1, 53 => 1, 54 => 1, 59 => 4, 62 => 1, 63 => 1, 64 => 1, 66 => 1, 69 => 1, 74 => 1, 77 => 1, 82 => 2, 86 => 2, 91 => 1, 95 => 1, 101 => 2, 105 => 2, 110 => 1, 116 => 2, ]; case 'ForLoopDeclarationUnitTest.js': return [ 6 => 2, 9 => 2, 12 => 2, 15 => 2, 19 => 6, 33 => 1, 36 => 1, 43 => 2, 45 => 2, 49 => 1, 55 => 1, 56 => 1, 59 => 1, 60 => 1, 65 => 4, 68 => 1, 69 => 1, 70 => 1, 72 => 1, 75 => 1, 80 => 1, 83 => 1, 88 => 2, 92 => 2, 97 => 1, 101 => 1, 107 => 2, 111 => 2, 116 => 1, 122 => 2, ]; default: return []; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getWarningList($testFile='ForLoopDeclarationUnitTest.inc') { switch ($testFile) { case 'ForLoopDeclarationUnitTest.inc': return [129 => 1]; case 'ForLoopDeclarationUnitTest.js': return [125 => 1]; default: return []; }//end switch }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/ControlStructures/InlineIfDeclarationUnitTest.inc0000644000076500000240000000267613614652362033041 0ustar gsherwoodstaffid.'"', '"'.$this->stepInfo['title'].'"', '"'.((isset($this->stepInfo['description']) === TRUE) ? $this->stepInfo['description'] : '').'"', '"'.(isset($this->stepInfo['description']) === TRUE ? $this->stepInfo['description'] : '').'"', '"'.$this->stepInfo['title'].'"', ); echo (TRUE)?'Hello':'Bye'; $array = array( 'one' => ($test == 1) ? true : false, 'two' => (($test == 1) ? true : false), 'three' => (($test == 1) ? true : false) ); $var = ($test == 1) ? true : false; $var = (myFunc(1,2,3) == 1) ? true : false; set('config', function() { $foo = ($bar === "on") ? "1" : "2"; }); $config = function() { $foo = ($bar === "on") ? "1" : "2"; }; rand(0, 1) ? 'ěščřžýáí' : NULL; $c = ($argv[1]) ? : ""; $filepath = realpath($argv[1]) ?: $argv[1]; $c = ($argv[1]) ? /* comment */ : ""; $c = ($argv[1]) ? : ""; ././@LongLink0000000000000000000000000000014700000000000007757 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/ControlStructures/InlineIfDeclarationUnitTest.inc.fixedPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/ControlStructures/InlineIfDeclarationUnitTest.inc.fi0000644000076500000240000000267413614652362033434 0ustar gsherwoodstaffid.'"', '"'.$this->stepInfo['title'].'"', '"'.((isset($this->stepInfo['description']) === TRUE) ? $this->stepInfo['description'] : '').'"', '"'.(isset($this->stepInfo['description']) === TRUE ? $this->stepInfo['description'] : '').'"', '"'.$this->stepInfo['title'].'"', ); echo (TRUE) ? 'Hello' : 'Bye'; $array = array( 'one' => ($test == 1) ? true : false, 'two' => (($test == 1) ? true : false), 'three' => (($test == 1) ? true : false) ); $var = ($test == 1) ? true : false; $var = (myFunc(1,2,3) == 1) ? true : false; set('config', function() { $foo = ($bar === "on") ? "1" : "2"; }); $config = function() { $foo = ($bar === "on") ? "1" : "2"; }; rand(0, 1) ? 'ěščřžýáí' : NULL; $c = ($argv[1]) ?: ""; $filepath = realpath($argv[1]) ?: $argv[1]; $c = ($argv[1]) ? /* comment */ : ""; $c = ($argv[1]) ? : ""; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/ControlStructures/InlineIfDeclarationUnitTest.php0000644000076500000240000000334113614652362033045 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\ControlStructures; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class InlineIfDeclarationUnitTest extends AbstractSniffUnitTest { /** * Get a list of CLI values to set before the file is tested. * * @param string $testFile The name of the file being tested. * * @return array */ public function getCliValues($testFile) { return ['--encoding=utf-8']; }//end getCliValues() /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 4 => 1, 5 => 1, 6 => 1, 7 => 1, 8 => 1, 9 => 1, 10 => 1, 13 => 1, 20 => 1, 24 => 4, 44 => 1, 47 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/ControlStructures/LowercaseDeclarationUnitTest.inc0000644000076500000240000000037513614652362033262 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\ControlStructures; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class LowercaseDeclarationUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 3 => 1, 5 => 1, 7 => 1, 9 => 1, 10 => 1, 12 => 1, 14 => 1, 15 => 1, 16 => 1, 20 => 1, 21 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/ControlStructures/SwitchDeclarationUnitTest.inc0000644000076500000240000001037713614652362032602 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\ControlStructures; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class SwitchDeclarationUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='SwitchDeclarationUnitTest.inc') { switch ($testFile) { case 'SwitchDeclarationUnitTest.inc': return [ 27 => 1, 29 => 1, 34 => 1, 36 => 1, 44 => 1, 48 => 1, 52 => 1, 54 => 1, 55 => 1, 56 => 1, 58 => 1, 59 => 1, 61 => 1, 62 => 1, 79 => 1, 85 => 2, 88 => 2, 89 => 2, 92 => 1, 95 => 3, 99 => 1, 116 => 1, 122 => 1, 127 => 2, 134 => 2, 135 => 1, 138 => 1, 143 => 1, 144 => 1, 147 => 1, 165 => 1, 172 => 1, 176 => 2, 180 => 1, 192 => 2, 196 => 1, 223 => 1, 266 => 1, 282 => 1, 284 => 2, 322 => 1, 323 => 1, 327 => 1, 329 => 1, 330 => 1, ]; case 'SwitchDeclarationUnitTest.js': return [ 27 => 1, 29 => 1, 34 => 1, 36 => 1, 44 => 1, 48 => 1, 52 => 1, 54 => 1, 55 => 1, 56 => 1, 58 => 1, 59 => 1, 61 => 1, 62 => 1, 79 => 1, 85 => 2, 88 => 2, 89 => 2, 92 => 1, 95 => 3, 99 => 1, 116 => 1, 122 => 1, 127 => 2, 134 => 2, 135 => 1, 138 => 1, 143 => 1, 144 => 1, 147 => 1, 165 => 1, 172 => 1, 176 => 2, 180 => 1, 192 => 2, 196 => 1, 223 => 1, 266 => 1, 282 => 1, 284 => 2, ]; default: return []; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getWarningList($testFile='SwitchDeclarationUnitTest.inc') { if ($testFile === 'SwitchDeclarationUnitTest.js') { return [273 => 1]; } return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/ClassDefinitionClosingBraceSpaceUnitTest.css0000644000076500000240000000246113614652362032417 0ustar gsherwoodstaff.my-style { } .my-style { } /* Comment */ .my-style { } /* Comment */ .my-style { float: left; } .AssetLineageWidgetType-item { color: #CCC; } /*.AssetLineageWidgetType-item2 .selected, .AssetLineageWidgetType-item .selected { }*/ .AssetLineageWidgetType-item.selected { } @media screen and (max-device-width: 769px) { header #logo img { max-width: 100%; } } @media screen and (max-device-width: 769px) { header #logo img { max-width: 100%; } } .GUITextBox.container:after {} @media screen and (max-device-width: 769px) { .no-blank-line-after { } .no-blank-line-after-second-def { } .my-style { } .no-blank-line-and-trailing-comment { } /* end long class */ .too-many-blank-lines-and-trailing-comment-extra-whitespace-after-brace { } /* end long class */ .has-blank-line-and-trailing-comment { } /* end long class */ .no-blank-line-and-annotation { } /* phpcs:ignore Standard.Cat.SniffName -- for reasons */ .too-many-blank-lines-annotation { } /* phpcs:ignore Standard.Cat.SniffName -- for reasons */ .has-blank-line-and-annotation { } /* phpcs:ignore Standard.Cat.SniffName -- for reasons */ } @media screen and (max-device-width: 769px) { header #logo img { max-width: 100%;}} ././@LongLink0000000000000000000000000000014600000000000007756 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/ClassDefinitionClosingBraceSpaceUnitTest.css.fixedPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/ClassDefinitionClosingBraceSpaceUnitTest.css.fix0000644000076500000240000000246513614652362033210 0ustar gsherwoodstaff.my-style { } .my-style { } /* Comment */ .my-style { } /* Comment */ .my-style { float: left; } .AssetLineageWidgetType-item { color: #CCC; } /*.AssetLineageWidgetType-item2 .selected, .AssetLineageWidgetType-item .selected { }*/ .AssetLineageWidgetType-item.selected { } @media screen and (max-device-width: 769px) { header #logo img { max-width: 100%; } } @media screen and (max-device-width: 769px) { header #logo img { max-width: 100%; } } .GUITextBox.container:after { } @media screen and (max-device-width: 769px) { .no-blank-line-after { } .no-blank-line-after-second-def { } .my-style { } .no-blank-line-and-trailing-comment { } /* end long class */ .too-many-blank-lines-and-trailing-comment-extra-whitespace-after-brace { } /* end long class */ .has-blank-line-and-trailing-comment { } /* end long class */ .no-blank-line-and-annotation { } /* phpcs:ignore Standard.Cat.SniffName -- for reasons */ .too-many-blank-lines-annotation { } /* phpcs:ignore Standard.Cat.SniffName -- for reasons */ .has-blank-line-and-annotation { } /* phpcs:ignore Standard.Cat.SniffName -- for reasons */ } @media screen and (max-device-width: 769px) { header #logo img { max-width: 100%; } } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/ClassDefinitionClosingBraceSpaceUnitTest.php0000644000076500000240000000265513614652362032423 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\CSS; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ClassDefinitionClosingBraceSpaceUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 2 => 1, 11 => 1, 44 => 1, 47 => 1, 51 => 1, 53 => 1, 57 => 1, 59 => 1, 67 => 1, 69 => 1, 81 => 2, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/ClassDefinitionNameSpacingUnitTest.css0000644000076500000240000000277113614652362031301 0ustar gsherwoodstaff.AssetListingEditWidgetType-BottomPanel select, #EditEditingModeWidgetType-assetEditor-filters-assetTypes-addNew { float: left; } .AssetListingEditWidgetType-BottomPanel select, #EditEditingModeWidgetType-assetEditor-filters-assetTypes-addNew { float: left; } .AssetListingEditWidgetType-BottomPanel select, /*.AssetListingEditWidgetType-BottomPanel ul,*/ #EditEditingModeWidgetType-assetEditor-filters-assetTypes-addNew { float: left; } .AssetListingEditWidgetType-BottomPanel select, .AssetListingEditWidgetType-BottomPanel ul, #EditEditingModeWidgetType-assetEditor-filters-assetTypes-addNew { float: left; } #SuperUsersSystemConfigScreen-table { display: block; left: 50%; margin-left: -500px; margin-top: 180px; position: relative; width: 1000px; } /** * More styles below here. */ td.TableWidgetType-header.TableWidgetType-header-lastLogin, td.TableWidgetType-header.TableWidgetType-header-remove, td.TableWidgetType-header.TableWidgetType-header-email, td.TableWidgetType-header.TableWidgetType-header-userName { background: url(images/ScreenImages/table_header_bg.png) repeat-x; border-top: 1px solid #D4D4D4; color: #787878; height: 33px; padding-left: 12px; width: 150px; } @media screen and (max-device-width: 769px) { header #logo img { max-width: 100%; padding: 20px; margin: 40px; } } .foo { border: none; } /* Live coding. Has to be the last test in the file. */ .intentional-parse-error { float: left PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/ClassDefinitionNameSpacingUnitTest.php0000644000076500000240000000234413614652362031274 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\CSS; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ClassDefinitionNameSpacingUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 7 => 1, 19 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/ClassDefinitionOpeningBraceSpaceUnitTest.css0000644000076500000240000000343513614652362032422 0ustar gsherwoodstaff.HelpWidgetType-new-bug-title { float: left; } .HelpWidgetType-new-bug-title { float: left; } .HelpWidgetType-new-bug-title { float: left; } .HelpWidgetType-new-bug-title{ float: left; } .HelpWidgetType-new-bug-title { float: left; } @media screen and (max-device-width: 769px) { header #logo img { max-width: 100%; } } @media screen and (max-device-width: 769px) { header #logo img { max-width: 100%; } } @media screen and (max-device-width: 769px) { header #logo img { max-width: 100%; } } .GUITextBox.container:after {} .single-line {float: left;} #opening-brace-on-different-line { color: #FFFFFF; } #opening-brace-on-different-line-and-inline-style {color: #FFFFFF;} @media screen and (max-device-width: 769px) { .everything-on-one-line { float: left; } } /* Document handling of comments in various places */ .no-space-before-opening-with-comment /* comment*/{ float: left; } .space-before-opening-with-comment-on-next-line /* comment*/ { float: left; } #opening-brace-on-different-line-with-comment-between /*comment*/ { padding: 0; } .single-line-with-comment { /* comment*/ float: left; } .multi-line-with-trailing-comment { /* comment*/ float: left; } @media screen and (max-device-width: 769px) { /*comment*/ .comment-line-after-nesting-class-opening { } } @media screen and (max-device-width: 769px) { /*comment*/ .blank-line-and-comment-line-after-nesting-class-opening { } } @media screen and (max-device-width: 769px) { /* phpcs:ignore Standard.Category.Sniffname -- for reasons */ .blank-line-and-annotation-after-nesting-class-opening { } } /* Live coding. Has to be the last test in the file. */ .intentional-parse-error { float: left ././@LongLink0000000000000000000000000000014600000000000007756 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/ClassDefinitionOpeningBraceSpaceUnitTest.css.fixedPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/ClassDefinitionOpeningBraceSpaceUnitTest.css.fix0000644000076500000240000000342713614652362033210 0ustar gsherwoodstaff.HelpWidgetType-new-bug-title { float: left; } .HelpWidgetType-new-bug-title { float: left; } .HelpWidgetType-new-bug-title { float: left; } .HelpWidgetType-new-bug-title { float: left; } .HelpWidgetType-new-bug-title { float: left; } @media screen and (max-device-width: 769px) { header #logo img { max-width: 100%; } } @media screen and (max-device-width: 769px) { header #logo img { max-width: 100%; } } @media screen and (max-device-width: 769px) { header #logo img { max-width: 100%; } } .GUITextBox.container:after { } .single-line { float: left;} #opening-brace-on-different-line { color: #FFFFFF; } #opening-brace-on-different-line-and-inline-style { color: #FFFFFF;} @media screen and (max-device-width: 769px) { .everything-on-one-line { float: left; } } /* Document handling of comments in various places */ .no-space-before-opening-with-comment /* comment*/ { float: left; } .space-before-opening-with-comment-on-next-line /* comment*/ { float: left; } #opening-brace-on-different-line-with-comment-between /*comment*/ { padding: 0; } .single-line-with-comment { /* comment*/ float: left; } .multi-line-with-trailing-comment { /* comment*/ float: left; } @media screen and (max-device-width: 769px) { /*comment*/ .comment-line-after-nesting-class-opening { } } @media screen and (max-device-width: 769px) { /*comment*/ .blank-line-and-comment-line-after-nesting-class-opening { } } @media screen and (max-device-width: 769px) { /* phpcs:ignore Standard.Category.Sniffname -- for reasons */ .blank-line-and-annotation-after-nesting-class-opening { } } /* Live coding. Has to be the last test in the file. */ .intentional-parse-error { float: left PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/ClassDefinitionOpeningBraceSpaceUnitTest.php0000644000076500000240000000300113614652362032406 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\CSS; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ClassDefinitionOpeningBraceSpaceUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 4 => 1, 7 => 1, 10 => 1, 26 => 1, 33 => 1, 43 => 1, 45 => 1, 50 => 1, 57 => 2, 59 => 2, 62 => 1, 73 => 1, 77 => 1, 84 => 1, 97 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/ColonSpacingUnitTest.css0000644000076500000240000000175313614652362026473 0ustar gsherwoodstaffbody { font-family: Arial, Helvetica, sans-serif; margin : 40px 0 0 0; padding : 0; background: #8FB7DB url(diag_lines_bg.gif) top left; margin-top: 10px; margin-bottom: 0px; } .TableWidgetType .recover:hover { background-color: #FFF; } #clearCache-settings:rootNodes-list_0 { border-top: none; } .LookupEditScreenWidgetType-urls a, .LookupEditScreenWidgetType-urls a:visited { text-decoration: none; color: #444; } /* checking embedded PHP */ li { background:url(/images//bullet.gif) left px no-repeat; margin:0px; padding-left:10px; margin-bottom:px; margin-top: px; line-height:13px; filter: progid:DXImageTransform.Microsoft.gradient(GradientType=0, startColorstr=#2e62a8, endColorstr=#123363); } /* Empty style defs. */ .p { margin:; margin-right: margin-left: 10px; float:/* Some comment. */ ; } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/ColonSpacingUnitTest.css.fixed0000644000076500000240000000175013614652362027566 0ustar gsherwoodstaffbody { font-family: Arial, Helvetica, sans-serif; margin: 40px 0 0 0; padding: 0; background: #8FB7DB url(diag_lines_bg.gif) top left; margin-top: 10px; margin-bottom: 0px; } .TableWidgetType .recover:hover { background-color: #FFF; } #clearCache-settings:rootNodes-list_0 { border-top: none; } .LookupEditScreenWidgetType-urls a, .LookupEditScreenWidgetType-urls a:visited { text-decoration: none; color: #444; } /* checking embedded PHP */ li { background: url(/images//bullet.gif) left px no-repeat; margin: 0px; padding-left: 10px; margin-bottom: px; margin-top: px; line-height: 13px; filter: progid:DXImageTransform.Microsoft.gradient(GradientType=0, startColorstr=#2e62a8, endColorstr=#123363); } /* Empty style defs. */ .p { margin:; margin-right: margin-left: 10px; float: /* Some comment. */ ; } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/ColonSpacingUnitTest.php0000644000076500000240000000260513614652362026467 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\CSS; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ColonSpacingUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 3 => 1, 4 => 2, 5 => 1, 6 => 1, 8 => 1, 27 => 1, 28 => 1, 29 => 1, 30 => 1, 32 => 1, 41 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/ColourDefinitionUnitTest.css0000644000076500000240000000066113614652362027365 0ustar gsherwoodstaff#title-bar-bottom-right { background-color: #333333; padding: 10px; border-bottom: 1px dotted #F0F0F0; border-top: 1px dotted #FF00FF; background: #08f7db url(diag_lines_bg.gif) top left; /* The sniff only deals with HEX colours. */ color: DarkSlateGray; background-color: rgb(255, 0, 0); background-color: rgba(0, 0, 255, 0.3); background-color: hsl(120, 100%, 50%); } #add-new-comment { } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/ColourDefinitionUnitTest.css.fixed0000644000076500000240000000065313614652362030464 0ustar gsherwoodstaff#title-bar-bottom-right { background-color: #333; padding: 10px; border-bottom: 1px dotted #F0F0F0; border-top: 1px dotted #F0F; background: #08F7DB url(diag_lines_bg.gif) top left; /* The sniff only deals with HEX colours. */ color: DarkSlateGray; background-color: rgb(255, 0, 0); background-color: rgba(0, 0, 255, 0.3); background-color: hsl(120, 100%, 50%); } #add-new-comment { } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/ColourDefinitionUnitTest.php0000644000076500000240000000234213614652362027362 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\CSS; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ColourDefinitionUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 2 => 1, 5 => 1, 6 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/DisallowMultipleStyleDefinitionsUnitTest.css0000644000076500000240000000152613614652362032621 0ustar gsherwoodstaff.SettingsTabPaneWidgetType-tab-mid { background: transparent url(tab_inact_mid.png) repeat-x; height: 100%;float: left; line-height: -25px; cursor: pointer; margin: 10px; float: right; } /* testing embedded PHP */ li { background:url(/images//bullet.gif) left px no-repeat; margin:0px; padding-left:10px; margin-bottom:px; line-height:13px; filter: progid:DXImageTransform.Microsoft.gradient(GradientType=0, startColorstr=#2e62a8, endColorstr=#123363); } /* Document handling of comments and annotations. */ div#annotations {-webkit-tap-highlight-color:transparent;/* phpcs:disable Standard.Cat.SniffName */-webkit-touch-callout:none;/*phpcs:enable*/-webkit-user-select:none;} div#comments {height:100%;/*comment*/width:100%;} ././@LongLink0000000000000000000000000000014600000000000007756 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/DisallowMultipleStyleDefinitionsUnitTest.css.fixedPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/DisallowMultipleStyleDefinitionsUnitTest.css.fix0000644000076500000240000000154013614652362033402 0ustar gsherwoodstaff.SettingsTabPaneWidgetType-tab-mid { background: transparent url(tab_inact_mid.png) repeat-x; height: 100%; float: left; line-height: -25px; cursor: pointer; margin: 10px; float: right; } /* testing embedded PHP */ li { background:url(/images//bullet.gif) left px no-repeat; margin:0px; padding-left:10px; margin-bottom:px; line-height:13px; filter: progid:DXImageTransform.Microsoft.gradient(GradientType=0, startColorstr=#2e62a8, endColorstr=#123363); } /* Document handling of comments and annotations. */ div#annotations {-webkit-tap-highlight-color:transparent;/* phpcs:disable Standard.Cat.SniffName */ -webkit-touch-callout:none;/*phpcs:enable*/ -webkit-user-select:none;} div#comments {height:100%;/*comment*/ width:100%;} PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/DisallowMultipleStyleDefinitionsUnitTest.php0000644000076500000240000000245713614652362032624 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\CSS; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class DisallowMultipleStyleDefinitionsUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 3 => 1, 5 => 2, 10 => 4, 15 => 2, 17 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/DuplicateClassDefinitionUnitTest.css0000644000076500000240000000222013614652362031013 0ustar gsherwoodstaff.AssetLineageWidgetType-item { color: #FFF; } .AssetLineageWidgetType-title { color: #CCC; } .AssetLineageWidgetType-item { color: #CCC; } .AssetLineageWidgetType-item .selected { } .AssetLineageWidgetType-item.selected { } #Blah .AssetLineageWidgetType-item { } #X.selected, .AssetLineageWidgetType-item { } .MyClass, .YourClass { } .YourClass, .MyClass { } .YourClass, .MyClass, .OurClass { } .ClassAtTopOfMediaBlock { } @media print { .ClassAtTopOfMediaBlock { } .ClassInMultipleMediaBlocks { } } .ClassNotAtTopOfMediaBlock { } @media handheld { .SameClassInMediaBlock { } .ClassNotAtTopOfMediaBlock { } .SameClassInMediaBlock { } } @media braille { .PlaceholderClass { } .ClassNotAtTopOfMediaBlock { } .ClassInMultipleMediaBlocks { } } .foo /* any comment */ { color: red; } /* print comment */ @media print { /* comment1 */ td { } /* comment2 */ img { } /* comment3 */ td { } } @media handheld /* handheld comment */ { td /* comment1 */ { } img /* comment2 */ { } td /* comment3 */ { } } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/DuplicateClassDefinitionUnitTest.php0000644000076500000240000000244413614652362031022 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\CSS; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class DuplicateClassDefinitionUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 9 => 1, 29 => 1, 57 => 1, 86 => 1, 101 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/DuplicateStyleDefinitionUnitTest.css0000644000076500000240000000124513614652362031054 0ustar gsherwoodstaff.ViperSubToolbar-wrapper { height: 34px; left: 0; position: fixed; top: 60px; z-index: 997; left: 50%; } .expandable { -moz-transition-property: margin-left, margin-right; -moz-transition-duration: 0.2s; -moz-transition-timing-function: ease; -webkit-transition-property: margin-left, margin-right; -webkit-transition-duration: 0.2s; -webkit-transition-timing-function: ease; z-index: 2; } @media only screen and (max-width: 480px) { header nav.meta a { display: none; } header nav.meta a.search { display: block; } } /* Live coding. Has to be the last test in the file. */ .intentional-parse-error { float: left PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/DuplicateStyleDefinitionUnitTest.php0000644000076500000240000000226313614652362031054 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\CSS; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class DuplicateStyleDefinitionUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [7 => 1]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/EmptyClassDefinitionUnitTest.css0000644000076500000240000000040013614652362030175 0ustar gsherwoodstaff.HelpWidgetType-new-bug-title {} .HelpWidgetType-new-bug-title { } .HelpWidgetType-new-bug-title { } .HelpWidgetType-new-bug-title { } .HelpWidgetType-new-bug-title { /* Nothing to see here */ } .HelpWidgetType-new-bug-title { float: left; } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/EmptyClassDefinitionUnitTest.php0000644000076500000240000000242713614652362030207 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\CSS; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class EmptyClassDefinitionUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 1 => 1, 2 => 1, 4 => 1, 7 => 1, 10 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/EmptyStyleDefinitionUnitTest.css0000644000076500000240000000035013614652362030234 0ustar gsherwoodstaff#MetadataAdminScreen-addField-fieldType { margin-left: 10px; margin-right: float: ; } #MetadataAdminScreen-addField-fieldType li { margin-right: /* @todo */ margin-left: 10px; float: /* Some comment. */ ; } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/EmptyStyleDefinitionUnitTest.php0000644000076500000240000000240213614652362030233 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\CSS; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class EmptyStyleDefinitionUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 3 => 1, 4 => 1, 8 => 1, 10 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/ForbiddenStylesUnitTest.css0000644000076500000240000000074013614652362027207 0ustar gsherwoodstaff#add-new-comment { -moz-border-radius: 1px; -webkit-border-radius: 1px; border-radius: 1px; -moz-border-radius-topleft: 1px; -moz-border-radius-topright: 1px; -moz-border-radius-bottomright: 1px; -moz-border-radius-bottomleft: 1px; border-top-left-radius: 1px; border-top-right-radius: 1px; border-bottom-right-radius: 1px; border-bottom-left-radius: 1px; -moz-box-shadow: 1px; -webkit-box-shadow: 1px; box-shadow: 1px; } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/ForbiddenStylesUnitTest.css.fixed0000644000076500000240000000066613614652362030314 0ustar gsherwoodstaff#add-new-comment { border-radius: 1px; border-radius: 1px; border-radius: 1px; border-top-left-radius: 1px; border-top-right-radius: 1px; border-bottom-right-radius: 1px; border-bottom-left-radius: 1px; border-top-left-radius: 1px; border-top-right-radius: 1px; border-bottom-right-radius: 1px; border-bottom-left-radius: 1px; box-shadow: 1px; box-shadow: 1px; box-shadow: 1px; } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/ForbiddenStylesUnitTest.php0000644000076500000240000000251413614652362027207 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\CSS; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ForbiddenStylesUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 2 => 1, 3 => 1, 6 => 1, 7 => 1, 8 => 1, 9 => 1, 15 => 1, 16 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/IndentationUnitTest.1.css0000644000076500000240000000253713614652362026530 0ustar gsherwoodstaffbody { font-family: Arial, Helvetica, sans-serif; margin: 40px 0 0 0; padding: 0; background: #8FB7DB url(diag_lines_bg.gif) top left; } td { margin: 40px; padding: 20px; } /* #AdminScreenModeWidgetType-tab_pane-containers .TabPaneWidgetType-tab-selected-left { background: transparent url(images/ScreenImages/tab_on_left.png) no-repeat; } #AdminScreenModeWidgetType-tab_pane-containers .TabPaneWidgetType-tab-selected-right { background: transparent url(images/ScreenImages/tab_on_right.png) no-repeat; } */ .GUITextBox.container:after {} @media screen and (max-device-width: 769px) { header #logo img { max-width: 100%; padding: 20px; margin: 40px; } } @media screen and (max-device-width: 769px) { header #logo img { max-width: 100%; } header #logo img { min-width: 100%; } } td { margin: 40px; padding: 20px; } .GUIFileUpload { /* opacity: 0.25; */ } .foo { border: none; } .mortgage-calculator h2 { background: #072237; color: #fff; font-weight: normal; height: 50px; line-height: 50px; padding: 0 0 0 30px; } .WhitelistCommentIndentationShouldBeIgnored { /* phpcs:disable Standard.Category.Sniff -- for reasons. */ } /* syntax error */ --------------------------------------------- */ PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/IndentationUnitTest.1.css.fixed0000644000076500000240000000247613614652362027630 0ustar gsherwoodstaffbody { font-family: Arial, Helvetica, sans-serif; margin: 40px 0 0 0; padding: 0; background: #8FB7DB url(diag_lines_bg.gif) top left; } td { margin: 40px; padding: 20px; } /* #AdminScreenModeWidgetType-tab_pane-containers .TabPaneWidgetType-tab-selected-left { background: transparent url(images/ScreenImages/tab_on_left.png) no-repeat; } #AdminScreenModeWidgetType-tab_pane-containers .TabPaneWidgetType-tab-selected-right { background: transparent url(images/ScreenImages/tab_on_right.png) no-repeat; } */ .GUITextBox.container:after {} @media screen and (max-device-width: 769px) { header #logo img { max-width: 100%; padding: 20px; margin: 40px; } } @media screen and (max-device-width: 769px) { header #logo img { max-width: 100%; } header #logo img { min-width: 100%; } } td { margin: 40px; padding: 20px; } .GUIFileUpload { /* opacity: 0.25; */ } .foo { border: none; } .mortgage-calculator h2 { background: #072237; color: #fff; font-weight: normal; height: 50px; line-height: 50px; padding: 0 0 0 30px; } .WhitelistCommentIndentationShouldBeIgnored { /* phpcs:disable Standard.Category.Sniff -- for reasons. */ } /* syntax error */ --------------------------------------------- */ PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/IndentationUnitTest.2.css0000644000076500000240000000014713614652362026524 0ustar gsherwoodstaff/* Live coding. Has to be the last (only) test in the file. */ .intentional-parse-error { float: left PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/IndentationUnitTest.php0000644000076500000240000000350113614652362026360 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\CSS; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class IndentationUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='') { switch ($testFile) { case 'IndentationUnitTest.1.css': return [ 2 => 1, 3 => 1, 5 => 1, 6 => 1, 7 => 1, 12 => 1, 30 => 1, 32 => 1, 50 => 1, 52 => 1, 53 => 1, 66 => 1, 67 => 1, 68 => 1, 69 => 1, 70 => 1, 71 => 1, 72 => 1, ]; default: return []; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/LowercaseStyleDefinitionUnitTest.css0000644000076500000240000000063113614652362031064 0ustar gsherwoodstaff.SettingsTabPaneWidgetType-tab-mid { font-family: Arial; Font-Family: arial; background-color: #DA9393; BACKGROUND-IMAGE: URL(Warning_Close.png); } @media screen and (max-device-width: 769px) { .SettingsTabPaneWidgetType-tab-mid { Font-Family: arial; filter: progid:DXImageTransform.Microsoft.gradient(GradientType=0, startColorstr=#2e62a8, endColorstr=#123363); } } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/LowercaseStyleDefinitionUnitTest.php0000644000076500000240000000241213614652362031062 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\CSS; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class LowercaseStyleDefinitionUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 2 => 1, 3 => 1, 5 => 2, 11 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/MissingColonUnitTest.css0000644000076500000240000000057513614652362026521 0ustar gsherwoodstaff.my-style { margin-right 15px; float: left; margin-left 15px; margin-top: 15px; margin-bottom 15px; } @media screen and (max-device-width: 769px) { header #logo img { max-width: 100%; margin-bottom 15px; } } #foo { background-color: #FF0000; } /* Live coding. Has to be the last test in the file. */ .intentional-parse-error { float PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/MissingColonUnitTest.php0000644000076500000240000000236213614652362026514 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\CSS; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class MissingColonUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 2 => 1, 4 => 1, 6 => 1, 12 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/NamedColoursUnitTest.css0000644000076500000240000000052113614652362026477 0ustar gsherwoodstaff#red { background-color: red; } .red { border-bottom: 1px dotted black; border-top: 1px dotted gray; } #red.yellow { background: yellow url(diag_lines_bg.gif) top left; text-shadow: 0 1px 0 white; } .something--white { border: 0; } .something--------------white { border: 0; } .-white { border: 0; } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/NamedColoursUnitTest.php0000644000076500000240000000240713614652362026503 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\CSS; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class NamedColoursUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 2 => 1, 6 => 1, 7 => 1, 11 => 1, 12 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/OpacityUnitTest.css0000644000076500000240000000146113614652362025520 0ustar gsherwoodstaff.my-style { opacity: 0; opacity: 0.0; opacity: 1; opacity: 1.0; opacity: 1.5; opacity: .5; opacity: 0.5; opacity: 2; opacity: -1; opacity: 0.55; } div { font-size: 1.2em; background: linear-gradient(to bottom, #00F, #0F0) repeat scroll 50% 50% #EEE; min-width: 250px; max-width: 100%; padding-bottom: 50px; box-shadow: 2px -3px 3px rgba(100, 100, 100, 0.33); border-left: 1px solid #000; border-right: 1px solid #000; border-top: 1px solid #000; border-bottom: 1px dotted #000; background: url(../1/2/3/4-5-6_7_100x100.png) repeat scroll 50% 50% #EEE; opacity: -1; } .my-commented-style { opacity: /*comment*/ 0; opacity: /* phpcs:ignore Standard.Cat.Sniff -- for reasons */ 0.0; opacity: /*comment*/ 1.0; opacity: /*comment*/ .5; } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/OpacityUnitTest.css.fixed0000644000076500000240000000145313614652362026617 0ustar gsherwoodstaff.my-style { opacity: 0; opacity: 0; opacity: 1; opacity: 1; opacity: 1.5; opacity: 0.5; opacity: 0.5; opacity: 2; opacity: -1; opacity: 0.55; } div { font-size: 1.2em; background: linear-gradient(to bottom, #00F, #0F0) repeat scroll 50% 50% #EEE; min-width: 250px; max-width: 100%; padding-bottom: 50px; box-shadow: 2px -3px 3px rgba(100, 100, 100, 0.33); border-left: 1px solid #000; border-right: 1px solid #000; border-top: 1px solid #000; border-bottom: 1px dotted #000; background: url(../1/2/3/4-5-6_7_100x100.png) repeat scroll 50% 50% #EEE; opacity: -1; } .my-commented-style { opacity: /*comment*/ 0; opacity: /* phpcs:ignore Standard.Cat.Sniff -- for reasons */ 0; opacity: /*comment*/ 1; opacity: /*comment*/ 0.5; } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/OpacityUnitTest.php0000644000076500000240000000257313614652362025524 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\CSS; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class OpacityUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 3 => 1, 5 => 1, 6 => 1, 7 => 1, 9 => 1, 10 => 1, 11 => 1, 26 => 1, 32 => 1, 33 => 1, 34 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/SemicolonSpacingUnitTest.css0000644000076500000240000000212713614652362027345 0ustar gsherwoodstaff.HelpWidgetType-new-bug-title { width: 308px float: left; } #MetadataAdminScreen-addField-add { float: left ; } .TableWidgetType .recover:hover { background-color: #FFF; } #clearCache-settings:rootNodes-list_0 { border-top: none; } .HelpWidgetType-list { list-style-image: url(); } @media (min-width: 320px) and (max-width: 961px) { .tooltipsrt:hover span.tltp, .tooltipstp:hover span.tltp { visibility: hidden; } } #single-line-multi-statement-no-semicolon { padding: 0 border: 20; } #multi-line-style-no-semicolon { padding: 0 /* phpcs:ignore Standard.Cat.Sniff -- for reasons */ border: 20 margin: 0px /* top */ 10px /* right + left */ } #multi-line-style-whitespace { padding: 0 /* phpcs:ignore Standard.Cat.Sniff -- for reasons */ ; border: 20 ; margin: 10px /* top */ 0px /* right + left */ ; } .allow-for-star-hack { cursor: pointer; *cursor: hand; } /* Live coding. Has to be the last test in the file. */ .intentional-parse-error { float: left PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/SemicolonSpacingUnitTest.css.fixed0000644000076500000240000000210513614652362030437 0ustar gsherwoodstaff.HelpWidgetType-new-bug-title { width: 308px float: left; } #MetadataAdminScreen-addField-add { float: left; } .TableWidgetType .recover:hover { background-color: #FFF; } #clearCache-settings:rootNodes-list_0 { border-top: none; } .HelpWidgetType-list { list-style-image: url(); } @media (min-width: 320px) and (max-width: 961px) { .tooltipsrt:hover span.tltp, .tooltipstp:hover span.tltp { visibility: hidden; } } #single-line-multi-statement-no-semicolon { padding: 0 border: 20; } #multi-line-style-no-semicolon { padding: 0 /* phpcs:ignore Standard.Cat.Sniff -- for reasons */ border: 20 margin: 0px /* top */ 10px /* right + left */ } #multi-line-style-whitespace { padding: 0; /* phpcs:ignore Standard.Cat.Sniff -- for reasons */ border: 20; margin: 10px /* top */ 0px; /* right + left */ } .allow-for-star-hack { cursor: pointer; *cursor: hand; } /* Live coding. Has to be the last test in the file. */ .intentional-parse-error { float: left PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/SemicolonSpacingUnitTest.php0000644000076500000240000000254313614652362027346 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\CSS; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class SemicolonSpacingUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 2 => 1, 7 => 1, 30 => 1, 34 => 1, 36 => 1, 39 => 1, 43 => 1, 45 => 1, 48 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/ShorthandSizeUnitTest.css0000644000076500000240000000254213614652362026676 0ustar gsherwoodstaff#add-new-comment { background-color: #333333; padding: 10px; border-bottom: 1px dotted #F0F0F0; border-top: 1px dotted #FF00FF; background: #8fb7db url(diag_lines_bg.gif) top left; tab-size: 1; margin: 8px 8px 8px 8px; margin: 8px 8px; margin: 0 0 0 0; margin: 0 8px 0 8px; margin: 8px 4px 8px 4px; margin: 8px 4% 8px 4%; margin: 6px 2px 9px 2px; margin: 6px 2px 9px; border-radius: 2px 2px 2px 2px !important; border-width: 2px 2px 2px 2px; border-width: 1px 2px 2px 4px; margin: 97px auto 0 auto; text-shadow: 0 1px 0 #fff; border-width: 2px 4px 2px 4px; /* These are style names excluded from this rule. */ background-position: 0 0; box-shadow: 2px 2px 2px 2px; transform-origin: 0 110% 0; /* Sizes with comments between them will be ignored for the purposes of this sniff. */ margin: 8px /*top*/ 8px /*right*/ 8px /*bottom*/ 8px /*left*/; /* Same with PHPCS annotations. */ border-width: 2px /* phpcs:ignore Standard.Category.SniffName -- for reasons */ 4px 2px /* phpcs:disable Standard.Category.SniffName -- for reasons */ 4px; } /* Intentional parse error. Live coding resilience. This has to be the last test in the file. */ #live-coding { margin: 8px 8px 8px 8px PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/ShorthandSizeUnitTest.css.fixed0000644000076500000240000000234513614652362027775 0ustar gsherwoodstaff#add-new-comment { background-color: #333333; padding: 10px; border-bottom: 1px dotted #F0F0F0; border-top: 1px dotted #FF00FF; background: #8fb7db url(diag_lines_bg.gif) top left; tab-size: 1; margin: 8px; margin: 8px; margin: 0; margin: 0 8px; margin: 8px 4px; margin: 8px 4%; margin: 6px 2px 9px 2px; margin: 6px 2px 9px 2px; border-radius: 2px !important; border-width: 2px; border-width: 1px 2px 2px 4px; margin: 97px auto 0 auto; text-shadow: 0 1px 0 #fff; border-width: 2px 4px; /* These are style names excluded from this rule. */ background-position: 0 0; box-shadow: 2px 2px 2px 2px; transform-origin: 0 110% 0; /* Sizes with comments between them will be ignored for the purposes of this sniff. */ margin: 8px /*top*/ 8px /*right*/ 8px /*bottom*/ 8px /*left*/; /* Same with PHPCS annotations. */ border-width: 2px /* phpcs:ignore Standard.Category.SniffName -- for reasons */ 4px 2px /* phpcs:disable Standard.Category.SniffName -- for reasons */ 4px; } /* Intentional parse error. Live coding resilience. This has to be the last test in the file. */ #live-coding { margin: 8px 8px 8px 8px PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/CSS/ShorthandSizeUnitTest.php0000644000076500000240000000256213614652362026677 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\CSS; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ShorthandSizeUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 8 => 1, 9 => 1, 10 => 1, 11 => 1, 12 => 1, 13 => 1, 15 => 1, 16 => 1, 17 => 1, 21 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Debug/JavaScriptLintUnitTest.js0000644000076500000240000000003113614652362027217 0ustar gsherwoodstaffalert('hi') alert('hi'); PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Debug/JavaScriptLintUnitTest.php0000644000076500000240000000277113614652362027407 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Debug; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; use PHP_CodeSniffer\Config; class JavaScriptLintUnitTest extends AbstractSniffUnitTest { /** * Should this test be skipped for some reason. * * @return void */ protected function shouldSkipTest() { $jslPath = Config::getExecutablePath('jsl'); if ($jslPath === null) { return true; } return false; }//end shouldSkipTest() /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return []; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return [2 => 1]; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Debug/JSLintUnitTest.js0000644000076500000240000000003113614652362025465 0ustar gsherwoodstaffalert('hi') alert('hi'); PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Debug/JSLintUnitTest.php0000644000076500000240000000302713614652362025650 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Debug; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; use PHP_CodeSniffer\Config; class JSLintUnitTest extends AbstractSniffUnitTest { /** * Should this test be skipped for some reason. * * @return void */ protected function shouldSkipTest() { $jslPath = Config::getExecutablePath('jslint'); if ($jslPath === null) { return true; } return false; }//end shouldSkipTest() /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return []; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return [ 1 => 2, 2 => 1, ]; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Files/FileExtensionUnitTest.1.inc0000644000076500000240000000004213614652362027410 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Files/FileExtensionUnitTest.2.inc0000644000076500000240000000003213614652362027410 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Files/FileExtensionUnitTest.3.inc0000644000076500000240000000004213614652362027412 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Files/FileExtensionUnitTest.4.inc0000644000076500000240000000003213614652362027412 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Files/FileExtensionUnitTest.php0000644000076500000240000000256313614652362027301 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Files; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class FileExtensionUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='') { switch ($testFile) { case 'FileExtensionUnitTest.1.inc': return [1 => 1]; default: return []; } }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Formatting/OperatorBracketUnitTest.inc0000644000076500000240000000752613614652362030652 0ustar gsherwoodstaffwords[$wordPos-1]) || $this->words[$wordPos-1] !== ' ') { } else if ($this->tokens[$pos + 1] === "\n") { } if ($pos === count($this->tokens) - 1) { $file = '...'.substr($file, (($padding * -1) + 3)); } if (substr($basename, -5) !== 'Sniff') { $i = ($this->_tokens[$i]['parenthesis_closer'] + 1); } $pos = $this->_getShortCommentEndPos(); if ($pos === -1) { $stackPtr = ($tokens[$next][$to] - 1); $stackPtr = ($tokens[$next][$pattern[$i]['to']] + 1); $var = (($var1 + $var2) + $var3 + $var4) } $commentStart = ($phpcsFile->findPrevious(T_DOC_COMMENT, ($commentEnd - 1), null, true) + 1); $commentEnd = ($this->_phpcsFile->findNext(T_DOC_COMMENT, ($commentStart + 1), null, true) - 1); $expected .= '...'.substr($tokens[($stackPtr - 2)]['content'], -5).$tokens[$stackPtr]['content']; if (($tokens[$nextToken - 1]['code']) !== T_WHITESPACE) { $errorPos = ($params[(count($params) - 1)]->getLine() + $commentStart); } while (($nextSpace = $phpcsFile->findNext(T_WHITESPACE, $nextSpace + 1, $nextBreak)) !== false) { } foreach ($attributes as $id => &$attribute) { } class MyClass { public function &myFunction(array &$one, array &$two) { }//end myFunction() }//end class if ($index < -1) $index = 0; if ($index < - 1) $index = 0; $three = ceil($one / $two); $three = ceil(($one / $two) / $four); $three = ceil($one / ($two / $four)); $four = -0.25; $three = ceil($one[1] / $two); switch ($number % 10) { case -1: $suffix = 'st'; break; } $expectedPermission = array( 'granted' => 4, 'denied' => 1, 'cascade' => TRUE, 'blockergranted' => 2, 'blockerdenied' => - 3, 'effective' => TRUE, ); $value = (int) isset($blah) + 2; $value = (int) isset($blah) + (int) isset($foo) + (int) isset($bar); doSomething(getValue($var, 2)) - $y; $codeFiles = array($global => $codeFiles[$global]) + $codeFiles; $var = array(-1); $var = [-1]; $var = [0, -1, -2]; $cntPages = ceil(count($items) / self::ON_PAGE); error_reporting(E_ALL & ~E_NOTICE & ~E_WARNING); error_reporting(E_ALL & ~E_NOTICE | ~E_WARNING); $results = $stmt->fetchAll(\PDO::FETCH_ASSOC | \PDO::FETCH_GROUP | \PDO::FETCH_UNIQUE); $di = new \RecursiveDirectoryIterator($path, \RecursiveDirectoryIterator::SKIP_DOTS | \FilesystemIterator::FOLLOW_SYMLINKS); foo(1 + 2 + 3); if (empty($foo[-1]) === true) { $foo[-1] = 'foo'; } try { } catch (AException | BException $e) { } $var = $foo['blah'] + []; $a = 2 * ${x} - ${minus}; $foo = $bar ?? $baz ?? ''; $foo = $myString{-1}; $value = (binary) $blah + b"binary $foo"; $test = (1 * static::TEST); $test = myfunc(1 * static::TEST); PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Formatting/OperatorBracketUnitTest.inc.fixed0000644000076500000240000000763213614652362031746 0ustar gsherwoodstaffwords[($wordPos-1)]) || $this->words[($wordPos-1)] !== ' ') { } else if ($this->tokens[($pos + 1)] === "\n") { } if ($pos === (count($this->tokens) - 1)) { $file = '...'.substr($file, (($padding * -1) + 3)); } if (substr($basename, -5) !== 'Sniff') { $i = ($this->_tokens[$i]['parenthesis_closer'] + 1); } $pos = $this->_getShortCommentEndPos(); if ($pos === -1) { $stackPtr = ($tokens[$next][$to] - 1); $stackPtr = ($tokens[$next][$pattern[$i]['to']] + 1); $var = (($var1 + $var2) + $var3 + $var4) } $commentStart = ($phpcsFile->findPrevious(T_DOC_COMMENT, ($commentEnd - 1), null, true) + 1); $commentEnd = ($this->_phpcsFile->findNext(T_DOC_COMMENT, ($commentStart + 1), null, true) - 1); $expected .= '...'.substr($tokens[($stackPtr - 2)]['content'], -5).$tokens[$stackPtr]['content']; if (($tokens[($nextToken - 1)]['code']) !== T_WHITESPACE) { $errorPos = ($params[(count($params) - 1)]->getLine() + $commentStart); } while (($nextSpace = $phpcsFile->findNext(T_WHITESPACE, ($nextSpace + 1), $nextBreak)) !== false) { } foreach ($attributes as $id => &$attribute) { } class MyClass { public function &myFunction(array &$one, array &$two) { }//end myFunction() }//end class if ($index < -1) $index = 0; if ($index < - 1) $index = 0; $three = ceil($one / $two); $three = ceil(($one / $two) / $four); $three = ceil($one / ($two / $four)); $four = -0.25; $three = ceil($one[1] / $two); switch ($number % 10) { case -1: $suffix = 'st'; break; } $expectedPermission = array( 'granted' => 4, 'denied' => 1, 'cascade' => TRUE, 'blockergranted' => 2, 'blockerdenied' => - 3, 'effective' => TRUE, ); $value = ((int) isset($blah) + 2); $value = ((int) isset($blah) + (int) isset($foo) + (int) isset($bar)); (doSomething(getValue($var, 2)) - $y); $codeFiles = (array($global => $codeFiles[$global]) + $codeFiles); $var = array(-1); $var = [-1]; $var = [0, -1, -2]; $cntPages = ceil(count($items) / self::ON_PAGE); error_reporting(E_ALL & ~E_NOTICE & ~E_WARNING); error_reporting(E_ALL & ~E_NOTICE | ~E_WARNING); $results = $stmt->fetchAll(\PDO::FETCH_ASSOC | \PDO::FETCH_GROUP | \PDO::FETCH_UNIQUE); $di = new \RecursiveDirectoryIterator($path, (\RecursiveDirectoryIterator::SKIP_DOTS | \FilesystemIterator::FOLLOW_SYMLINKS)); foo(1 + 2 + 3); if (empty($foo[-1]) === true) { $foo[-1] = 'foo'; } try { } catch (AException | BException $e) { } $var = ($foo['blah'] + []); $a = 2 * ${x} - ${minus}; $foo = ($bar ?? $baz ?? ''); $foo = $myString{-1}; $value = ((binary) $blah + b"binary $foo"); $test = (1 * static::TEST); $test = myfunc(1 * static::TEST); PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Formatting/OperatorBracketUnitTest.js0000644000076500000240000000404213614652362030503 0ustar gsherwoodstaffvalue = (one + two); value = one + two; value = (one - two); value = one - two; value = (one * two); value = one * two; value = (one / two); value = one / two; value = (one % two); value = one % two; value = (one + two + three); value = one + two + three; value = (one + (two + three)); value = one + (two + three); value++; value--; value = -1; value = - 1; value = (1 + 2); value = 1 + 2; value = (1 - 2); value = 1 - 2; value = (1 * 2); value = 1 * 2; value = (1 / 2); value = 1 / 2; value = (1 % 2); value = 1 % 2; value = (1 + 2 + 3); value = 1 + 2 + 3; value = (1 + (2 + 3)); value = 1 + (2 + 3); value = one + 2 + 3 - (four * five * (6 + 7)) + nine + 2; value = myFunction(tokens[stackPtr - 1]); for (i = 1 + 2; i < 4 + 5; i++) { } function myFunction() { value = (one + 1) + (two + 2) + (myFunction() + 2); value = myFunction() + 2; value = (myFunction(mvar) + myFunction2(mvar)); return -1; } params['mode'] = id.replace(/WidgetType/, ''); if (index < -1) index = 0; if (index < - 1) index = 0; var classN = prvId.replace(/\./g, '-'); three = myFunction(one / two); three = myFunction((one / two) / four); three = myFunction(one / (two / four)); four = -0.25; id = id.replace(/row\/:/gi, ''); return /MSIE/.test(navigator.userAgent); var re = new RegExp(/<\/?(\w+)((\s+\w+(\s*=\s*(?:".*?"|'.*?'|[^'">\s]+))?)+\s*|\s*)\/?>/gim); var options = { minVal: -1, maxVal: -1 }; stepWidth = Math.round(this.width / 5); date.setMonth(d[2] - 1); switch (number % 10) { case -1: suffix = 'st'; break; } var pathSplit = ipt.value.split(/\/|\\/); if (pairs[i].search(/=/) !== -1) { } if (urlValue.search(/[a-zA-z]+:\/\//) !== 0) { } if (urlValue.search(/[a-zA-z]+:\/\/*/) !== 0) { } if (!value || /^\s*$/.test(value)) { return true; } parseInt(dfx.attr(selectors[idx], 'elemOffsetTop'), 10) - scrollCoords.y + 'px' if (something === true ^ somethingElse === true ) { return false; } if (true === /^\d*\.?\d*$/.test(input)) return true; if ( ! /^(?:a|select)$/i.test( element.tagName ) ) return true; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Formatting/OperatorBracketUnitTest.js.fixed0000644000076500000240000000407013614652362031602 0ustar gsherwoodstaffvalue = (one + two); value = one + two; value = (one - two); value = (one - two); value = (one * two); value = (one * two); value = (one / two); value = (one / two); value = (one % two); value = (one % two); value = (one + two + three); value = one + two + three; value = (one + (two + three)); value = one + (two + three); value++; value--; value = -1; value = - 1; value = (1 + 2); value = 1 + 2; value = (1 - 2); value = (1 - 2); value = (1 * 2); value = (1 * 2); value = (1 / 2); value = (1 / 2); value = (1 % 2); value = (1 % 2); value = (1 + 2 + 3); value = 1 + 2 + 3; value = (1 + (2 + 3)); value = 1 + (2 + 3); value = one + 2 + (3 - (four * five * (6 + 7))) + nine + 2; value = myFunction(tokens[(stackPtr - 1)]); for (i = 1 + 2; i < 4 + 5; i++) { } function myFunction() { value = (one + 1) + (two + 2) + (myFunction() + 2); value = myFunction() + 2; value = (myFunction(mvar) + myFunction2(mvar)); return -1; } params['mode'] = id.replace(/WidgetType/, ''); if (index < -1) index = 0; if (index < - 1) index = 0; var classN = prvId.replace(/\./g, '-'); three = myFunction(one / two); three = myFunction((one / two) / four); three = myFunction(one / (two / four)); four = -0.25; id = id.replace(/row\/:/gi, ''); return /MSIE/.test(navigator.userAgent); var re = new RegExp(/<\/?(\w+)((\s+\w+(\s*=\s*(?:".*?"|'.*?'|[^'">\s]+))?)+\s*|\s*)\/?>/gim); var options = { minVal: -1, maxVal: -1 }; stepWidth = Math.round(this.width / 5); date.setMonth(d[2] - 1); switch (number % 10) { case -1: suffix = 'st'; break; } var pathSplit = ipt.value.split(/\/|\\/); if (pairs[i].search(/=/) !== -1) { } if (urlValue.search(/[a-zA-z]+:\/\//) !== 0) { } if (urlValue.search(/[a-zA-z]+:\/\/*/) !== 0) { } if (!value || /^\s*$/.test(value)) { return true; } (parseInt(dfx.attr(selectors[idx], 'elemOffsetTop'), 10) - scrollCoords.y) + 'px' if (something === true ^ somethingElse === true ) { return false; } if (true === /^\d*\.?\d*$/.test(input)) return true; if ( ! /^(?:a|select)$/i.test( element.tagName ) ) return true; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Formatting/OperatorBracketUnitTest.php0000644000076500000240000000545513614652362030667 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Formatting; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class OperatorBracketUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='OperatorBracketUnitTest.inc') { switch ($testFile) { case 'OperatorBracketUnitTest.inc': return [ 3 => 1, 6 => 1, 9 => 1, 12 => 1, 15 => 1, 18 => 2, 20 => 1, 25 => 1, 28 => 1, 31 => 1, 34 => 1, 37 => 1, 40 => 1, 43 => 2, 45 => 1, 47 => 5, 48 => 1, 50 => 2, 55 => 2, 56 => 1, 63 => 2, 64 => 1, 67 => 1, 86 => 1, 90 => 1, 109 => 1, 130 => 1, 134 => 1, 135 => 2, 137 => 1, 139 => 1, 150 => 1, 161 => 1, 163 => 2, 165 => 2, 169 => 1, ]; break; case 'OperatorBracketUnitTest.js': return [ 5 => 1, 8 => 1, 11 => 1, 14 => 1, 24 => 1, 30 => 1, 33 => 1, 36 => 1, 39 => 1, 46 => 1, 47 => 1, 63 => 1, 108 => 1, ]; break; default: return []; break; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class ././@LongLink0000000000000000000000000000015000000000000007751 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Functions/FunctionDeclarationArgumentSpacingUnitTest.incPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Functions/FunctionDeclarationArgumentSpacingUnitTest0000644000076500000240000000602413614652362033604 0ustar gsherwoodstaff $a($b); ././@LongLink0000000000000000000000000000015600000000000007757 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Functions/FunctionDeclarationArgumentSpacingUnitTest.inc.fixedPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Functions/FunctionDeclarationArgumentSpacingUnitTest0000644000076500000240000000567713614652362033621 0ustar gsherwoodstaff $a($b); ././@LongLink0000000000000000000000000000015000000000000007751 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Functions/FunctionDeclarationArgumentSpacingUnitTest.phpPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Functions/FunctionDeclarationArgumentSpacingUnitTest0000644000076500000240000000377713614652362033620 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Functions; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class FunctionDeclarationArgumentSpacingUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 3 => 1, 5 => 2, 7 => 2, 8 => 2, 9 => 2, 11 => 2, 13 => 7, 14 => 2, 15 => 2, 16 => 4, 18 => 2, 35 => 2, 36 => 2, 44 => 2, 45 => 1, 46 => 1, 51 => 2, 53 => 2, 55 => 1, 56 => 1, 58 => 1, 73 => 7, 76 => 1, 77 => 1, 81 => 1, 89 => 2, 92 => 1, 93 => 1, 94 => 1, 95 => 1, 99 => 11, 100 => 2, 101 => 2, 102 => 2, 106 => 1, 107 => 2, 111 => 3, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Functions/FunctionDeclarationUnitTest.inc0000644000076500000240000000123413614652362031342 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Functions; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class FunctionDeclarationUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 55 => 1, 68 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Functions/FunctionDuplicateArgumentUnitTest.inc0000644000076500000240000000022713614652362032533 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Functions/FunctionDuplicateArgumentUnitTest.php0000644000076500000240000000237213614652362032554 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Functions; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class FunctionDuplicateArgumentUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 2 => 1, 4 => 2, 5 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Functions/GlobalFunctionUnitTest.inc0000644000076500000240000000041213614652362030312 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Functions/GlobalFunctionUnitTest.php0000644000076500000240000000224513614652362030336 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Functions; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class GlobalFunctionUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return []; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return [2 => 1]; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Functions/LowercaseFunctionKeywordsUnitTest.inc0000644000076500000240000000132713614652362032574 0ustar gsherwoodstaff $x; ././@LongLink0000000000000000000000000000014500000000000007755 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Functions/LowercaseFunctionKeywordsUnitTest.inc.fixedPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Functions/LowercaseFunctionKeywordsUnitTest.inc.fixe0000644000076500000240000000132713614652362033526 0ustar gsherwoodstaff $x; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Functions/LowercaseFunctionKeywordsUnitTest.php0000644000076500000240000000257313614652362032616 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Functions; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class LowercaseFunctionKeywordsUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 16 => 1, 17 => 1, 20 => 1, 21 => 1, 22 => 1, 23 => 1, 24 => 3, 25 => 4, 28 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Functions/MultiLineFunctionDeclarationUnitTest.inc0000644000076500000240000000561013614652362033167 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Functions; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class MultiLineFunctionDeclarationUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='MultiLineFunctionDeclarationUnitTest.inc') { if ($testFile === 'MultiLineFunctionDeclarationUnitTest.inc') { $errors = [ 2 => 1, 3 => 1, 4 => 2, 5 => 1, 7 => 1, 11 => 1, 12 => 1, 13 => 1, 16 => 1, 36 => 1, 43 => 2, 48 => 1, 81 => 1, 82 => 2, 88 => 1, 102 => 2, 137 => 1, 141 => 2, 142 => 1, 158 => 1, 160 => 1, 182 => 2, 186 => 2, 190 => 2, 194 => 1, 195 => 1, 196 => 1, ]; } else { $errors = [ 2 => 1, 3 => 1, 4 => 2, 5 => 1, 7 => 1, 11 => 1, 12 => 1, 13 => 1, 16 => 1, 26 => 1, 36 => 1, 43 => 2, 48 => 1, 65 => 1, ]; }//end if return $errors; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/NamingConventions/ValidFunctionNameUnitTest.inc0000644000076500000240000000117213614652362032445 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/NamingConventions/ValidFunctionNameUnitTest.php0000644000076500000240000000261013614652362032461 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\NamingConventions; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ValidFunctionNameUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 4 => 1, 5 => 1, 6 => 1, 7 => 1, 8 => 1, 9 => 1, 11 => 1, 12 => 1, 13 => 1, 14 => 2, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/NamingConventions/ValidVariableNameUnitTest.inc0000644000076500000240000000475113614652362032413 0ustar gsherwoodstaffvarName2; echo $this->var_name2; echo $this->varname2; echo $this->_varName2; echo $object->varName2; echo $object->var_name2; echo $object_name->varname2; echo $object_name->_varName2; echo $this->myFunction($one, $two); echo $object->myFunction($one_two); $error = "format is \$GLOBALS['$varName']"; echo $_SESSION['var_name']; echo $_FILES['var_name']; echo $_ENV['var_name']; echo $_COOKIE['var_name']; $XML = 'hello'; $myXML = 'hello'; $XMLParser = 'hello'; $xmlParser = 'hello'; echo "{$_SERVER['HOSTNAME']} $var_name"; // Need to be the last thing in this test file. $obj->$classVar = $prefix.'-'.$type; class foo { const bar = << * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\NamingConventions; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ValidVariableNameUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { $errors = [ 3 => 1, 5 => 1, 10 => 1, 12 => 1, 15 => 1, 17 => 1, 20 => 1, 22 => 1, 25 => 1, 27 => 1, 31 => 1, 33 => 1, 36 => 1, 37 => 1, 39 => 1, 42 => 1, 44 => 1, 53 => 1, 58 => 1, 62 => 1, 63 => 1, 64 => 1, 67 => 1, 81 => 1, 106 => 1, 107 => 2, 108 => 1, 111 => 1, 112 => 1, 113 => 1, 114 => 1, 123 => 1, 138 => 1, 141 => 1, ]; return $errors; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Objects/DisallowObjectStringIndexUnitTest.js0000644000076500000240000000142213614652362031756 0ustar gsherwoodstafffunction test(id) { this.id = id; } /**/ test.prototype = { init: function() { var x = {}; x.name = 'test'; x['phone'] = 123124324; var t = ['test', 'this'].join(''); var y = ['test'].join(''); var a = x[0]; var z = x[x['name']]; var p = x[x.name]; } }; function test() { this.errors['step_' + step] = errors; this.errors['test'] = x; this.errors['test' + 10] = x; this.errors['test' + y] = x; this.errors['test' + 'blah'] = x; this.errors[y] = x; this.errors[y + z] = x; this.permissions['workflow.cancel'] = x; } if (child.prototype) { above.prototype['constructor'] = parent; child.prototype['super'] = new above(); } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Objects/DisallowObjectStringIndexUnitTest.php0000644000076500000240000000275313614652362032141 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Objects; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class DisallowObjectStringIndexUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='DisallowObjectStringIndexUnitTest.js') { if ($testFile !== 'DisallowObjectStringIndexUnitTest.js') { return []; } return [ 13 => 1, 17 => 1, 25 => 1, 35 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Objects/ObjectInstantiationUnitTest.inc0000644000076500000240000000044413614652362031005 0ustar gsherwoodstaff new MyClass()); $object->myFunction(new MyClass()); throw new MyException($msg); function foo() { return new MyClass(); } $doodad = $x ? new Foo : new Bar; function new ?> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Objects/ObjectInstantiationUnitTest.php0000644000076500000240000000233013614652362031017 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Objects; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ObjectInstantiationUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 5 => 1, 8 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Objects/ObjectMemberCommaUnitTest.js0000644000076500000240000000170313614652362030207 0ustar gsherwoodstaffthis.request({ action: 'getTypeFormatContents', }); addTypeFormatButton.addClickEvent(function() { self.addNewTypeFormat(); }); var x = {}; var y = { VarOne : 'If you ask me, thats if you ask', VarTwo : ['Alonzo played you', 'for a fool', 'esse'], VarThree: function(arg) { console.info(1); } }; var z = { VarOne : 'If you ask me, thats if you ask', VarTwo : ['Alonzo played you', 'for a fool', 'esse'], VarThree: function(arg) { console.info(1); }, }; var x = function() { console.info(2); }; AssetListingEditWidgetType.prototype = { init: function(data, assetid, editables) { } }; AssetListingEditWidgetType.prototype = { init: function(data, assetid, editables) { }, }; AssetListingEditWidgetType.prototype = { // phpcs: disable Standard.Cat.SniffName -- testing annotation between closing brace and comma init: function(data, assetid, editables) { }, // phpcs:enable }; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Objects/ObjectMemberCommaUnitTest.js.fixed0000644000076500000240000000167713614652362031317 0ustar gsherwoodstaffthis.request({ action: 'getTypeFormatContents' }); addTypeFormatButton.addClickEvent(function() { self.addNewTypeFormat(); }); var x = {}; var y = { VarOne : 'If you ask me, thats if you ask', VarTwo : ['Alonzo played you', 'for a fool', 'esse'], VarThree: function(arg) { console.info(1); } }; var z = { VarOne : 'If you ask me, thats if you ask', VarTwo : ['Alonzo played you', 'for a fool', 'esse'], VarThree: function(arg) { console.info(1); } }; var x = function() { console.info(2); }; AssetListingEditWidgetType.prototype = { init: function(data, assetid, editables) { } }; AssetListingEditWidgetType.prototype = { init: function(data, assetid, editables) { } }; AssetListingEditWidgetType.prototype = { // phpcs: disable Standard.Cat.SniffName -- testing annotation between closing brace and comma init: function(data, assetid, editables) { } // phpcs:enable }; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Objects/ObjectMemberCommaUnitTest.php0000644000076500000240000000240013614652362030355 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Objects; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ObjectMemberCommaUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 1 => 1, 22 => 1, 38 => 1, 45 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Operators/ComparisonOperatorUsageUnitTest.inc0000644000076500000240000000423013614652362032227 0ustar gsherwoodstaff 0)) { } myFunction($var1 === true ? "" : "foobar"); PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Operators/ComparisonOperatorUsageUnitTest.js0000644000076500000240000000215413614652362032075 0ustar gsherwoodstaffif (value === TRUE) { } else if (value === FALSE) { } if (value == TRUE) { } else if (value == FALSE) { } if (value) { } else if (!value) { } if (value.isSomething === TRUE) { } else if (myFunction(value) === FALSE) { } if (value.isSomething == TRUE) { } else if (myFunction(value) == FALSE) { } if (value.isSomething) { } else if (!myFunction(value)) { } if (value === TRUE || other === FALSE) { } if (value == TRUE || other == FALSE) { } if (value || !other) { } if (one === TRUE || two === TRUE || three === FALSE || four === TRUE) { } if (one || two || !three || four) { } while (one == true) { } while (one === true) { } do { } while (one == true); do { } while (one === true); for (one = 10; one != 0; one--) { } for (one = 10; one !== 0; one--) { } for (type in types) { } variable = (variable2 === true) ? variable1 : "foobar"; variable = (variable2 == true) ? variable1 : "foobar"; variable = (variable2 === false) ? variable1 : "foobar"; variable = (variable2 == false) ? variable1 : "foobar"; variable = (variable2 === 0) ? variable1 : "foobar"; variable = (variable2 == 0) ? variable1 : "foobar"; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Operators/ComparisonOperatorUsageUnitTest.php0000644000076500000240000000510413614652362032246 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Operators; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ComparisonOperatorUsageUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='ComparisonOperatorUsageUnitTest.inc') { switch ($testFile) { case 'ComparisonOperatorUsageUnitTest.inc': return [ 6 => 1, 7 => 1, 10 => 1, 11 => 1, 18 => 1, 19 => 1, 22 => 1, 23 => 1, 29 => 2, 32 => 2, 38 => 4, 47 => 2, 69 => 1, 72 => 1, 75 => 1, 78 => 1, 80 => 1, 82 => 1, 83 => 1, 89 => 1, 92 => 1, 100 => 1, 106 => 1, 112 => 1, 123 => 1, 127 => 1, 131 => 1, 135 => 1, ]; break; case 'ComparisonOperatorUsageUnitTest.js': return [ 5 => 1, 6 => 1, 17 => 1, 18 => 1, 28 => 2, 40 => 1, 47 => 1, 52 => 1, 63 => 1, 67 => 1, 71 => 1, ]; break; default: return []; break; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Operators/IncrementDecrementUsageUnitTest.inc0000644000076500000240000000136313614652362032160 0ustar gsherwoodstaffi++).$id; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Operators/IncrementDecrementUsageUnitTest.php0000644000076500000240000000256713614652362032205 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Operators; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class IncrementDecrementUsageUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 2 => 1, 6 => 1, 12 => 1, 16 => 1, 25 => 1, 26 => 1, 27 => 1, 29 => 1, 31 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Operators/ValidLogicalOperatorsUnitTest.inc0000644000076500000240000000057013614652362031650 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Operators/ValidLogicalOperatorsUnitTest.php0000644000076500000240000000236513614652362031672 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Operators; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ValidLogicalOperatorsUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 5 => 1, 11 => 1, 17 => 2, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/CommentedOutCodeUnitTest.css0000644000076500000240000000075113614652362027306 0ustar gsherwoodstaff/* CSS Document */ body { font-family: Arial, Helvetica, sans-serif; margin : 40px 0 0 0; padding : 0; /*background: #8FB7DB url(login_glow_bg.jpg) no-repeat 30% 0;*/ background: #8FB7DB url(diag_lines_bg.gif) top left; } #login-container { margin-left: -225px; margin-top: -161px; position:absolute; top :50%; /*left :50%;*/ width:450px; } #cacheConfig-dayLabel, #cacheConfig-hourLabel, #cacheConfig-minuteLabel { float: left; padding-right: 8px; } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/CommentedOutCodeUnitTest.inc0000644000076500000240000000576613614652362027302 0ustar gsherwoodstaff * * Title * Contents * * ... * * * * * @return void */ /* [^\'"] */ // http://www.google.com // Base config function. // function () // T_STRING is not a function call or not listed in _getFunctionListWithCallableArgument(). // function myFunction( $param ) // { // do_something(); // }//end myFunction() // /* function myFunction( $param ) { // phpcs:disable Standard.Category.Sniff -- for reasons. if ( preg_match( '`[abc]`', $param ) > 0 ) { do_something(); } // phpcs:enable Standard.Category.Sniff -- for reasons. }//end myFunction() */ /* * function myFunction( $param ) // @phpcs:ignore Standard.Category.Sniff -- for reasons. * { * * }//end myFunction() */ /* * function myFunction( $param ) * { * // phpcs:disable Standard.Category.Sniff -- for reasons. * if ( preg_match( '`[abc]`', $param ) > 0 ) { * do_something(); * } * // phpcs:enable Standard.Category.Sniff -- for reasons. * * }//end myFunction() */ // function myFunction( $param ) // { // phpcs:disable Standard.Category.Sniff -- for reasons. // do_something(); // phpcs:enable Standard.Category.Sniff -- for reasons. // }//end myFunction() // echo 'something'; // @codeCoverageIgnore echo 'something'; // @codeCoverageIgnoreStart echo 'something'; // @SuppressWarnings(PHPMD.UnusedLocalVariable) // Ok! /* Go! */ // ISO-639-3 // But override with a different text if any. /* $id = intval( str_replace( 'hook_name', '', $order_method['method_id'] ) ); if ( ! empty( $id ) ) { $info_text = get_post_meta( $location_id, 'meta_name' ); if ( ! empty( $info_text ) ) { $text = $info_text; } } */ // function() { $a = $b; }; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/CommentedOutCodeUnitTest.php0000644000076500000240000000366513614652362027314 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class CommentedOutCodeUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return []; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getWarningList($testFile='CommentedOutCodeUnitTest.inc') { switch ($testFile) { case 'CommentedOutCodeUnitTest.inc': return [ 6 => 1, 8 => 1, 15 => 1, 19 => 1, 35 => 1, 87 => 1, 91 => 1, 97 => 1, 109 => 1, 116 => 1, 128 => 1, 147 => 1, 158 => 1, ]; break; case 'CommentedOutCodeUnitTest.css': return [ 7 => 1, 16 => 1, ]; break; default: return []; break; }//end switch }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/DisallowBooleanStatementUnitTest.inc0000644000076500000240000000054113614652362031031 0ustar gsherwoodstaffPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/DisallowBooleanStatementUnitTest.php0000644000076500000240000000241213614652362031046 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class DisallowBooleanStatementUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 3 => 1, 8 => 1, 13 => 1, 15 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/DisallowComparisonAssignmentUnitTest.inc0000644000076500000240000000226513614652362031735 0ustar gsherwoodstaffnextSibling; $node; $node = $node->nextSibling) { if ($node->nodeType !== XML_ELEMENT_NODE) { continue; } for ($node = $fields->nextSibling; $node; $node = $node->nextSibling) { if ($node->nodeType !== XML_ELEMENT_NODE) { continue; } } } $a = $b ? $c : $d; $a = $b === true ? $c : $d; $this->_args = $this->_getArgs(($_SERVER['argv'] ?? [])); $args = ($_SERVER['argv'] ?? []); $a = [ 'a' => ($foo) ? $foo : $bar, ]; $a = [ 'a' => ($foo) ? fn() => return 1 : fn() => return 2, ]; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/DisallowComparisonAssignmentUnitTest.php0000644000076500000240000000262013614652362031746 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class DisallowComparisonAssignmentUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 3 => 1, 5 => 1, 6 => 1, 7 => 1, 8 => 1, 10 => 1, 52 => 1, 53 => 1, 58 => 1, 62 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/DisallowInlineIfUnitTest.inc0000644000076500000240000000044213614652362027262 0ustar gsherwoodstaff $x; $b = fn ($b) => $b ? true : false; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/DisallowInlineIfUnitTest.js0000644000076500000240000000005613614652362027126 0ustar gsherwoodstaffx = (x?a:x); id = id.replace(/row\/:/gi, ''); PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/DisallowInlineIfUnitTest.php0000644000076500000240000000313513614652362027302 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class DisallowInlineIfUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='DisallowInlineIfUnitTest.inc') { switch ($testFile) { case 'DisallowInlineIfUnitTest.inc': return [ 8 => 1, 18 => 1, ]; break; case 'DisallowInlineIfUnitTest.js': return [1 => 1]; break; default: return []; break; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/DisallowMultipleAssignmentsUnitTest.inc0000644000076500000240000000244413614652362031600 0ustar gsherwoodstafffetch(PDO::FETCH_NUM)) { $result[$row[0]] = array(); $result[$row[0]][] = $current; self::$_inTransaction = TRUE; parent::$_inTransaction = TRUE; static::$_inTransaction = TRUE; $$varName = $varValue; } }//end getVar() class myClass { private static $_dbh = NULL; public $dbh = NULL; protected $dbh = NULL; var $dbh = NULL; // Old PHP4 compatible code. } A::$a = 'b'; \A::$a = 'c'; \A\B\C::$d = 'd'; B\C::$d = 'e'; @$a = 1; $a = []; foreach ($a as $b) $c = 'd'; $var = $var2; list ($a, $b) = explode(',', $c); $var1 ? $var2 = 0 : $var2 = 1; $obj->$classVar = $prefix.'-'.$type; $closureWithDefaultParamter = function(array $testArray=array()) {}; ?> * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class DisallowMultipleAssignmentsUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 4 => 1, 5 => 2, 7 => 1, 9 => 1, 12 => 1, 14 => 1, 15 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/DisallowSizeFunctionsInLoopsUnitTest.inc0000644000076500000240000000134013614652362031672 0ustar gsherwoodstaffchildren); $i++) { } for ($i = 0; $i < sizeof($array); $i++) { } $num = sizeof($array); while ($i < sizeof($array)) { } do { } while ($i < sizeof($array)); for ($i = 0; $i < sizeof($this->children); $i++) { } for ($i = 0; $i < strlen($string); $i++) { } $num = strlen($string); while ($i < strlen($string)) { } do { } while ($i < strlen($string)); for ($i = 0; $i < strlen($this->string); $i++) { } for ($i = sizeof($array); $i > 0; $i--) { } do { echo $a->count; $a->count--; } while($a->count); for ($i = 0; $i < $a->count; $i++) {} ?> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/DisallowSizeFunctionsInLoopsUnitTest.js0000644000076500000240000000037513614652362031544 0ustar gsherwoodstafffor (var i = 0; i < permissions.length; i++) { // Code here. } var permLen = permissions.length; for (var length = 0; i < permLen; i++) { // Code here. } var myArray = [1, 2, 3, 4]; for (var i = myArray.length; i >= 0; i--) { var x = i; } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/DisallowSizeFunctionsInLoopsUnitTest.php0000644000076500000240000000362113614652362031714 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class DisallowSizeFunctionsInLoopsUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='DisallowSizeFunctionsInLoopsUnitTest.inc') { switch ($testFile) { case 'DisallowSizeFunctionsInLoopsUnitTest.inc': return [ 2 => 1, 7 => 1, 11 => 1, 13 => 1, 18 => 1, 23 => 1, 27 => 1, 29 => 1, 35 => 1, 40 => 1, 44 => 1, 46 => 1, ]; break; case 'DisallowSizeFunctionsInLoopsUnitTest.js': return [1 => 1]; break; default: return []; break; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/DiscouragedFunctionsUnitTest.inc0000644000076500000240000000007713614652362030214 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/DiscouragedFunctionsUnitTest.php0000644000076500000240000000235213614652362030230 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class DiscouragedFunctionsUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return []; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return [ 2 => 1, 3 => 1, 4 => 1, ]; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/EmbeddedPhpUnitTest.inc0000644000076500000240000000360613614652362026234 0ustar gsherwoodstaff <?php echo $title ?> hello section as $section) { ?> section as $section) { ?>
    ?> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/EmbeddedPhpUnitTest.inc.fixed0000644000076500000240000000363613614652362027335 0ustar gsherwoodstaff <?php echo $title; ?> hello section as $section) { ?>
    section as $section) { ?>
    ?> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/EmbeddedPhpUnitTest.php0000644000076500000240000000343213614652362026247 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class EmbeddedPhpUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 7 => 1, 12 => 1, 18 => 1, 19 => 2, 20 => 1, 21 => 1, 22 => 3, 24 => 1, 26 => 1, 29 => 1, 30 => 1, 31 => 1, 34 => 1, 36 => 1, 40 => 1, 41 => 1, 44 => 1, 45 => 1, 49 => 1, 59 => 1, 63 => 1, 93 => 1, 94 => 2, 100 => 1, 102 => 1, 112 => 1, 113 => 1, 116 => 1, 117 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/EvalUnitTest.inc0000644000076500000240000000010213614652362024746 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/EvalUnitTest.php0000644000076500000240000000226613614652362025001 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class EvalUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return []; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return [ 2 => 1, 4 => 1, ]; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/GlobalKeywordUnitTest.inc0000644000076500000240000000025513614652362026635 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/GlobalKeywordUnitTest.php0000644000076500000240000000231013614652362026645 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class GlobalKeywordUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 8 => 1, 9 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/HeredocUnitTest.inc0000644000076500000240000000106013614652362025434 0ustar gsherwoodstafffoo. Now, I am printing some {$foo->bar[1]}. This should not print a capital 'A': \x41 EOT; // The following function has a simulated git conflict for testing. // This is not a merge conflict - it is a valid test case. // Please do not remove. function test() { $arr = array( 'a' => 'a' <<<<<<< HEAD 'b' => 'b' ======= 'c' => 'c' >>>>>>> master ); } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/HeredocUnitTest.php0000644000076500000240000000227413614652362025462 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class HeredocUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 2 => 1, 8 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/InnerFunctionsUnitTest.inc0000644000076500000240000000143213614652362027032 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class InnerFunctionsUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 5 => 1, 46 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/LowercasePHPFunctionsUnitTest.inc0000644000076500000240000000173113614652362030255 0ustar gsherwoodstaffCount(); $count = $object::Count(); $count = $object->count(); $count = $object::count(); class MyClass { public function Count() {} } function &Sort() { } $connection = new Db\Adapter\Pdo\Mysql($config); namespace Strtolower\Silly; use function strToUpper as somethingElse; use function MyClass\WordsToUpper as UCWords; // Intentional redeclared function error. use function strToUpper\NotTheFunction; class ArrayUnique {} $sillyComments = strToLower /*comment*/ ($string); $callToGlobalFunction = \STR_REPEAT($a, 2); $callToGlobalFunction = \ /*comment*/ str_Repeat($a, 2); $callToNamespacedFunction = MyNamespace /* phpcs:ignore Standard */ \STR_REPEAT($a, 2); $callToNamespacedFunction = namespace\STR_REPEAT($a, 2); // Could potentially be false negative. $filePath = new \File($path); PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/LowercasePHPFunctionsUnitTest.inc.fixed0000644000076500000240000000173113614652362031353 0ustar gsherwoodstaffCount(); $count = $object::Count(); $count = $object->count(); $count = $object::count(); class MyClass { public function Count() {} } function &Sort() { } $connection = new Db\Adapter\Pdo\Mysql($config); namespace Strtolower\Silly; use function strtoupper as somethingElse; use function MyClass\WordsToUpper as UCWords; // Intentional redeclared function error. use function strToUpper\NotTheFunction; class ArrayUnique {} $sillyComments = strtolower /*comment*/ ($string); $callToGlobalFunction = \str_repeat($a, 2); $callToGlobalFunction = \ /*comment*/ str_repeat($a, 2); $callToNamespacedFunction = MyNamespace /* phpcs:ignore Standard */ \STR_REPEAT($a, 2); $callToNamespacedFunction = namespace\STR_REPEAT($a, 2); // Could potentially be false negative. $filePath = new \File($path); PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/LowercasePHPFunctionsUnitTest.php0000644000076500000240000000245613614652362030300 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class LowercasePHPFunctionsUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 2 => 1, 4 => 1, 27 => 1, 33 => 1, 35 => 1, 36 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/NonExecutableCodeUnitTest.1.inc0000644000076500000240000001154213614652362027557 0ustar gsherwoodstaff{$action . 'JsonAction'}(); } switch (true) { case 1: return foo( function () { $foo = $bar; // when this is removed it works ok return false; // from here on it reports unreachable } ); } for($i=0,$j=50; $i<100; $i++) { while($j--) { if($j==17) { goto end; echo 'unreachable'; } } } switch ($var) { case '1': goto end; echo 'hi'; case '2': case '3': if ($something === true) { goto end; echo 'hi'; } break; default: goto end; if ($something === true) { goto end; echo 'hi'; } } end: echo 'j hit 17'; // Issue 2512. class TestAlternativeControlStructures { public function alternative_switch_in_function( $var ) { switch ( $var ) : case 'value1': do_something(); break; default: case 'value2': do_something_else(); break; endswitch; } public function various_alternative_control_structures() { $_while = 1; for ( $a = 0; $a++ < 1; ) : foreach ( [ 1 ] as $b ) : while ( $_while-- ) : if ( 1 ) : switch ( 1 ) : default: echo 'yay, we made it!'; break; endswitch; endif; endwhile; endforeach; endfor; } } $var_after_class_in_global_space = 1; do_something_else(); PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/PHP/NonExecutableCodeUnitTest.2.inc0000644000076500000240000000126713614652362027563 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\PHP; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class NonExecutableCodeUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return []; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getWarningList($testFile='') { switch ($testFile) { case 'NonExecutableCodeUnitTest.1.inc': return [ 5 => 1, 11 => 1, 17 => 1, 18 => 1, 19 => 2, 28 => 1, 32 => 1, 33 => 2, 34 => 2, 42 => 1, 45 => 1, 54 => 1, 58 => 1, 73 => 1, 83 => 1, 95 => 1, 105 => 1, 123 => 1, 147 => 1, 150 => 1, 153 => 1, 166 => 1, 180 => 1, 232 => 1, 240 => 1, 246 => 1, 252 => 1, 253 => 1, 254 => 2, ]; break; case 'NonExecutableCodeUnitTest.2.inc': return [ 7 => 1, 8 => 1, 9 => 1, 10 => 2, 14 => 1, 48 => 2, ]; break; default: return []; break; }//end switch }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Scope/MemberVarScopeUnitTest.inc0000644000076500000240000000253613614652362027370 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Scope; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class MemberVarScopeUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 7 => 1, 25 => 1, 29 => 1, 33 => 1, 39 => 1, 41 => 1, 66 => 2, 67 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return [71 => 1]; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Scope/MethodScopeUnitTest.inc0000644000076500000240000000131313614652362026720 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Scope; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class MethodScopeUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 6 => 1, 30 => 1, 39 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Scope/StaticThisUsageUnitTest.inc0000644000076500000240000000272613614652362027563 0ustar gsherwoodstafffunc2()); $result = $this->getValue($value); return $this->setValue($result); } public static function /* */ func1() { return $this->setValue($result); } public static function func1() { return $this->setValue($result); } public function func1() { $value = 'hello'; $newValue = array($this->func2()); $result = $this->getValue($value); return $this->setValue($result); } function func1() { $value = 'hello'; $newValue = array($this->func2()); $result = $this->getValue($value); return $this->setValue($result); } public static function func1() { return function() { echo $this->name; }; } private static function func1(array $data) { return new class() { private $data; public function __construct(array $data) { $this->data = $data; } }; } public function getAnonymousClass() { return new class() { public static function something() { $this->doSomething(); } }; } } trait MyTrait { public static function myFunc() { $this->doSomething(); } } $b = new class() { public static function myFunc() { $this->doSomething(); } } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Scope/StaticThisUsageUnitTest.php0000644000076500000240000000251613614652362027576 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Scope; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class StaticThisUsageUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 7 => 1, 8 => 1, 9 => 1, 14 => 1, 20 => 1, 61 => 1, 69 => 1, 76 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Strings/ConcatenationSpacingUnitTest.inc0000644000076500000240000000167313614652362031171 0ustar gsherwoodstaffadd_help_tab( array( 'id' => <<', ) ); // phpcs:set Squiz.Strings.ConcatenationSpacing spacing 1 $string = 'Hello'.$there.'. How are'.$you.$going. "today $okay"; $string = 'Hello' . $there . '. How are' . $you . $going . "today $okay"; $string = 'Hello'.$there; $string = 'Hello'. $there; $string = 'Hello' .$there; // phpcs:set Squiz.Strings.ConcatenationSpacing ignoreNewlines true $y = '1' . '2' . '3'; $y = '1' . '2' . '3'; $y = '1' . '2' . '3'; $y = '1' .'2'. '3' . '4'; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Strings/ConcatenationSpacingUnitTest.inc.fixed0000644000076500000240000000165013614652362032262 0ustar gsherwoodstaffadd_help_tab( array( 'id' => <<', ) ); // phpcs:set Squiz.Strings.ConcatenationSpacing spacing 1 $string = 'Hello' . $there . '. How are' . $you . $going . "today $okay"; $string = 'Hello' . $there . '. How are' . $you . $going . "today $okay"; $string = 'Hello' . $there; $string = 'Hello' . $there; $string = 'Hello' . $there; // phpcs:set Squiz.Strings.ConcatenationSpacing ignoreNewlines true $y = '1' . '2' . '3'; $y = '1' . '2' . '3'; $y = '1' . '2' . '3'; $y = '1' . '2' . '3' . '4'; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Strings/ConcatenationSpacingUnitTest.php0000644000076500000240000000302713614652362031202 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Strings; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ConcatenationSpacingUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 3 => 5, 5 => 1, 6 => 1, 9 => 1, 10 => 1, 12 => 1, 13 => 1, 14 => 1, 15 => 1, 16 => 5, 22 => 1, 27 => 5, 29 => 1, 30 => 1, 31 => 1, 47 => 2, 49 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Strings/DoubleQuoteUsageUnitTest.inc0000644000076500000240000000127313614652362030310 0ustar gsherwoodstaff"; $string = "Value: $var[test]"; $string = "\0"; $string = "\$var"; $x = "bar = '$z', baz = '" . $a . "'...$x"; $string = "Hello there"; $string = 'Hello there'; $string = "\123 \234"."\u123"."\e"; echo "window.location = \"".$url."\";\n"; echo "" $string = "Hello there"; function test() { echo "It Worked'; } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Strings/DoubleQuoteUsageUnitTest.inc.fixed0000644000076500000240000000127113614652362031404 0ustar gsherwoodstaff"; $string = "Value: $var[test]"; $string = "\0"; $string = '$var'; $x = "bar = '$z', baz = '" . $a . "'...$x"; $string = 'Hello there'; $string = 'Hello there'; $string = "\123 \234"."\u123"."\e"; echo 'window.location = "'.$url."\";\n"; echo '' $string = 'Hello there'; function test() { echo "It Worked'; } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Strings/DoubleQuoteUsageUnitTest.php0000644000076500000240000000267313614652362030333 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Strings; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class DoubleQuoteUsageUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 4 => 1, 5 => 1, 6 => 1, 8 => 2, 14 => 1, 15 => 1, 17 => 1, 19 => 1, 20 => 1, 22 => 1, 29 => 1, 30 => 1, 32 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Strings/EchoedStringsUnitTest.inc0000644000076500000240000000045413614652362027634 0ustar gsherwoodstaffreturndate == 0) ? 'Not returned' : date('d/m/Y', $loan_device->returndate); ?>

    PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Strings/EchoedStringsUnitTest.inc.fixed0000644000076500000240000000044313614652362030730 0ustar gsherwoodstaffreturndate == 0) ? 'Not returned' : date('d/m/Y', $loan_device->returndate); ?>

    PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/Strings/EchoedStringsUnitTest.php0000644000076500000240000000244213614652362027651 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\Strings; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class EchoedStringsUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 5 => 1, 6 => 1, 7 => 1, 8 => 1, 9 => 1, 13 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/CastSpacingUnitTest.inc0000644000076500000240000000024513614652362027673 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\WhiteSpace; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class CastSpacingUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 3 => 1, 4 => 1, 5 => 1, 6 => 1, 9 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/ControlStructureSpacingUnitTest.inc0000644000076500000240000000617413614652362032351 0ustar gsherwoodstaff
    children as $child) { // There should be no error after this // foreach, because it is followed by a // close PHP tag. } ?>
    children as $child) { echo $child; } if ($defaultPageDesign === 0 && $defaultCascade === TRUE && $defaultChildDesign === 0 ) { $settingsUpdated = FALSE; } foreach ( $blah as $var ) { if ( $blah ) { } } if ( $defaultPageDesign === 0 && $defaultCascade === TRUE && $defaultChildDesign === 0 ) { $settingsUpdated = FALSE; } $moo = 'blar'; switch ($moo) { case 'blar': if ($moo === 'blar2') { $moo = 'blar' } return $moo; default: $moo = 'moo'; break; } do { } while (true); try { // Something } catch (Exception $e) { // Something } try { // Something } catch (Exception $e) { // Something } if ($one) { } elseif ($two) { } // else if something else if ($three) { } // else do something else { } if ($one) { } do { echo 'hi'; } while ( $blah ); if ($one) { } // No blank line here. if ($two) { } switch ($moo) { case 'blar': if ($moo === 'blar2') { $moo = 'blar' } return $moo; } try { // Something } catch (Exception $e) { // Something } finally { // Something } if ($foo) { /** * Comment */ function foo() { // Code here } /** * Comment */ class bar() { }//end class } if (true) { // some comment goes here echo 'foo'; } if (true) { echo 'foo'; echo 'foo'; } if ($true) { echo 'hi 2'; }//end if echo 'hi'; if ($true) { echo 'hi 2'; } // phpcs:enable Standard.Category.Sniff -- for reasons. echo 'hi'; ?> ././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/ControlStructureSpacingUnitTest.inc.fixedPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/ControlStructureSpacingUnitTest.inc.fixed0000644000076500000240000000614513614652362033445 0ustar gsherwoodstaff
    children as $child) { // There should be no error after this // foreach, because it is followed by a // close PHP tag. } ?>
    children as $child) { echo $child; } if ($defaultPageDesign === 0 && $defaultCascade === TRUE && $defaultChildDesign === 0 ) { $settingsUpdated = FALSE; } foreach ($blah as $var) { if ($blah) { } } if ($defaultPageDesign === 0 && $defaultCascade === TRUE && $defaultChildDesign === 0 ) { $settingsUpdated = FALSE; } $moo = 'blar'; switch ($moo) { case 'blar': if ($moo === 'blar2') { $moo = 'blar' } return $moo; default: $moo = 'moo'; break; } do { } while (true); try { // Something } catch (Exception $e) { // Something } try { // Something } catch (Exception $e) { // Something } if ($one) { } elseif ($two) { } // else if something else if ($three) { } // else do something else { } if ($one) { } do { echo 'hi'; } while ($blah); if ($one) { } // No blank line here. if ($two) { } switch ($moo) { case 'blar': if ($moo === 'blar2') { $moo = 'blar' } return $moo; } try { // Something } catch (Exception $e) { // Something } finally { // Something } if ($foo) { /** * Comment */ function foo() { // Code here } /** * Comment */ class bar() { }//end class } if (true) { // some comment goes here echo 'foo'; } if (true) { echo 'foo'; echo 'foo'; } if ($true) { echo 'hi 2'; }//end if echo 'hi'; if ($true) { echo 'hi 2'; } // phpcs:enable Standard.Category.Sniff -- for reasons. echo 'hi'; ?> PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/ControlStructureSpacingUnitTest.js0000644000076500000240000000211713614652362032205 0ustar gsherwoodstaff if (something) { } for (i = 0; i < 10; i++) { } while (true) { for (i = 0; i < 10; i++) { } if (something) { } do { } while (true); } if (one) { } else (two) { } else if (three) { } if (one) { } else (two) { } else if (three) { } switch (blah) { case 'one': if (blah) { // There are no spaces before break. } break; default: if (blah) { // There are no spaces before break. } break; } switch (blah) { case 'one': if (blah) { // There are no spaces before break. } break; default: if (blah) { // Code here. } } for (i = 0; i < 10; i++) { if (blah) { } break; } while (true) { for (i = 0; i < 10; i++) { if (something) { } } do { alert(i); } while (true); } for ( i = 0; i < 10; i++ ) { if ( blah ) { } } var x = { a: function () { if (blah) { } }, }; if (one) { } // else if something else if (two) { } // else do something else { } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/ControlStructureSpacingUnitTest.js.fixed0000644000076500000240000000210713614652362033302 0ustar gsherwoodstaff if (something) { } for (i = 0; i < 10; i++) { } while (true) { for (i = 0; i < 10; i++) { } if (something) { } do { } while (true); } if (one) { } else (two) { } else if (three) { } if (one) { } else (two) { } else if (three) { } switch (blah) { case 'one': if (blah) { // There are no spaces before break. } break; default: if (blah) { // There are no spaces before break. } break; } switch (blah) { case 'one': if (blah) { // There are no spaces before break. } break; default: if (blah) { // Code here. } } for (i = 0; i < 10; i++) { if (blah) { } break; } while (true) { for (i = 0; i < 10; i++) { if (something) { } } do { alert(i); } while (true); } for (i = 0; i < 10; i++) { if (blah) { } } var x = { a: function () { if (blah) { } }, }; if (one) { } // else if something else if (two) { } // else do something else { } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/ControlStructureSpacingUnitTest.php0000644000076500000240000000505313614652362032362 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\WhiteSpace; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ControlStructureSpacingUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='ControlStructureSpacingUnitTest.inc') { switch ($testFile) { case 'ControlStructureSpacingUnitTest.inc': return [ 3 => 1, 5 => 1, 8 => 1, 15 => 1, 23 => 1, 74 => 1, 79 => 1, 82 => 1, 83 => 1, 87 => 1, 103 => 1, 113 => 2, 114 => 2, 118 => 1, 150 => 1, 153 => 1, 154 => 1, 157 => 1, 170 => 1, 176 => 2, 179 => 1, 189 => 1, 225 => 1, 237 => 1, 242 => 1, 246 => 1, 248 => 1, ]; break; case 'ControlStructureSpacingUnitTest.js': return [ 3 => 1, 9 => 1, 15 => 1, 21 => 1, 56 => 1, 61 => 1, 64 => 1, 65 => 1, 68 => 1, 74 => 2, 75 => 2, ]; break; default: return []; break; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/FunctionClosingBraceSpaceUnitTest.inc0000644000076500000240000000072213614652362032511 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\WhiteSpace; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class FunctionClosingBraceSpaceUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='FunctionClosingBraceSpaceUnitTest.inc') { switch ($testFile) { case 'FunctionClosingBraceSpaceUnitTest.inc': return [ 10 => 1, 21 => 1, 28 => 1, 29 => 1, 31 => 1, 39 => 1, ]; break; case 'FunctionClosingBraceSpaceUnitTest.js': return [ 13 => 1, 25 => 1, 32 => 1, 53 => 1, 59 => 1, 67 => 1, 84 => 1, 128 => 1, ]; break; default: return []; break; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/FunctionOpeningBraceSpaceUnitTest.inc0000644000076500000240000000114313614652362032510 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\WhiteSpace; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class FunctionOpeningBraceSpaceUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='FunctionOpeningBraceSpaceUnitTest.inc') { switch ($testFile) { case 'FunctionOpeningBraceSpaceUnitTest.inc': return [ 10 => 1, 25 => 1, 49 => 1, ]; case 'FunctionOpeningBraceSpaceUnitTest.js': return [ 11 => 1, 31 => 1, 38 => 1, 88 => 1, ]; default: return []; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/FunctionSpacingUnitTest.1.inc0000644000076500000240000001642213614652362030731 0ustar gsherwoodstaffsetLogger(new class { public function a(){} private function b(){} protected function c(){} }); ?> setLogger(new class { public function a(){} private function b(){} protected function c(){} }); ?> * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\WhiteSpace; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class FunctionSpacingUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='') { switch ($testFile) { case 'FunctionSpacingUnitTest.1.inc': return [ 26 => 1, 35 => 1, 44 => 1, 51 => 1, 55 => 1, 61 => 1, 64 => 1, 66 => 1, 81 => 1, 100 => 1, 111 => 1, 113 => 1, 119 => 2, 141 => 1, 160 => 1, 173 => 2, 190 => 1, 224 => 2, 281 => 1, 282 => 1, 295 => 1, 297 => 1, 303 => 1, 327 => 1, 329 => 1, 338 => 1, 344 => 1, 345 => 1, 354 => 2, 355 => 1, 356 => 1, 360 => 2, 361 => 1, 362 => 1, 385 => 1, 399 => 1, 411 => 2, 418 => 2, 426 => 2, 432 => 1, 437 => 1, 438 => 1, 442 => 2, 444 => 1, 449 => 1, 458 => 2, 459 => 1, 460 => 1, 465 => 2, 466 => 1, 467 => 1, 471 => 1, 473 => 2, 475 => 1, 478 => 2, 479 => 1, 483 => 2, 495 => 1, 529 => 1, 539 => 1, ]; case 'FunctionSpacingUnitTest.2.inc': return [2 => 1]; case 'FunctionSpacingUnitTest.3.inc': return [7 => 1]; case 'FunctionSpacingUnitTest.5.inc': return [5 => 1]; case 'FunctionSpacingUnitTest.6.inc': return [10 => 1]; default: return []; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/LanguageConstructSpacingUnitTest.inc0000644000076500000240000000115513614652362032432 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\WhiteSpace; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class LanguageConstructSpacingUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 3 => 1, 7 => 1, 11 => 1, 15 => 1, 19 => 1, 23 => 1, 27 => 1, 31 => 1, 34 => 1, 35 => 1, 39 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/LogicalOperatorSpacingUnitTest.inc0000644000076500000240000000040313614652362032063 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\WhiteSpace; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class LogicalOperatorSpacingUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='LogicalOperatorSpacingUnitTest.inc') { return [ 4 => 2, 5 => 3, 6 => 3, 15 => 1, 17 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/MemberVarSpacingUnitTest.inc0000644000076500000240000001111213614652362030654 0ustar gsherwoodstaff 'a', 'b' => 'b' ), $varQ = 'string', $varR = 123; } // Make sure the determination of whether a property is the first property or not is done correctly. class ClassUsingSimpleTraits { use HelloWorld; /* comment */ public $firstVar = array( 'a', 'b' ); protected $secondVar = true; } class ClassUsingComplexTraits { use A, B { B::smallTalk insteadof A; A::bigTalk insteadof B; } public $firstVar = array( 'a', 'b' ); /* comment */ protected $secondVar = true; } class Foo { private function foo() { } /* no error here because after function */ private $bar = false; } class CommentedOutCodeAtStartOfClass { /** * Description. * * @var bool */ //public $commented_out_property = true; /** * Description. * * @var bool */ public $property = true; } class CommentedOutCodeAtStartOfClassNoBlankLine { // phpcs:disable Stnd.Cat.Sniff -- For reasons. /** * Description. * * @var bool */ public $property = true; } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/MemberVarSpacingUnitTest.inc.fixed0000644000076500000240000001107513614652362031762 0ustar gsherwoodstaff 'a', 'b' => 'b' ), $varQ = 'string', $varR = 123; } // Make sure the determination of whether a property is the first property or not is done correctly. class ClassUsingSimpleTraits { use HelloWorld; /* comment */ public $firstVar = array( 'a', 'b' ); protected $secondVar = true; } class ClassUsingComplexTraits { use A, B { B::smallTalk insteadof A; A::bigTalk insteadof B; } public $firstVar = array( 'a', 'b' ); /* comment */ protected $secondVar = true; } class Foo { private function foo() { } /* no error here because after function */ private $bar = false; } class CommentedOutCodeAtStartOfClass { /** * Description. * * @var bool */ //public $commented_out_property = true; /** * Description. * * @var bool */ public $property = true; } class CommentedOutCodeAtStartOfClassNoBlankLine { // phpcs:disable Stnd.Cat.Sniff -- For reasons. /** * Description. * * @var bool */ public $property = true; } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/MemberVarSpacingUnitTest.php0000644000076500000240000000352713614652362030705 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\WhiteSpace; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class MemberVarSpacingUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 4 => 1, 7 => 1, 20 => 1, 30 => 1, 35 => 1, 44 => 1, 50 => 1, 73 => 1, 86 => 1, 106 => 1, 115 => 1, 150 => 1, 160 => 1, 165 => 1, 177 => 1, 186 => 1, 200 => 1, 209 => 1, 211 => 1, 224 => 1, 229 => 1, 241 => 1, 246 => 1, 252 => 1, 254 => 1, 261 => 1, 275 => 1, 276 => 1, 288 => 1, 292 => 1, 333 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/ObjectOperatorSpacingUnitTest.inc0000644000076500000240000000214713614652362031726 0ustar gsherwoodstafftestThis(); $this-> testThis(); $this -> testThis(); $this-> /* comment here */testThis(); $this/* comment here */ -> testThis(); $this ->testThis(); $this-> testThis(); // phpcs:set Squiz.WhiteSpace.ObjectOperatorSpacing ignoreNewlines true $this->testThis(); $this-> testThis(); $this -> testThis(); $this->/* comment here */testThis(); $this/* comment here */ -> testThis(); $this ->testThis(); $this-> testThis(); // phpcs:set Squiz.WhiteSpace.ObjectOperatorSpacing ignoreNewlines false thisObject::testThis(); thisObject:: testThis(); thisObject :: testThis(); thisObject::/* comment here */testThis(); thisObject/* comment here */ :: testThis(); thisObject ::testThis(); thisObject:: testThis(); // phpcs:set Squiz.WhiteSpace.ObjectOperatorSpacing ignoreNewlines true thisObject::testThis(); thisObject:: testThis(); thisObject :: testThis(); thisObject::/* comment here */testThis(); thisObject/* comment here */ :: testThis(); thisObject ::testThis(); thisObject:: testThis(); // phpcs:set Squiz.WhiteSpace.ObjectOperatorSpacing ignoreNewlines false PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/ObjectOperatorSpacingUnitTest.inc.fixed0000644000076500000240000000205613614652362033023 0ustar gsherwoodstafftestThis(); $this->testThis(); $this->testThis(); $this->/* comment here */testThis(); $this/* comment here */->testThis(); $this->testThis(); $this->testThis(); // phpcs:set Squiz.WhiteSpace.ObjectOperatorSpacing ignoreNewlines true $this->testThis(); $this->testThis(); $this->testThis(); $this->/* comment here */testThis(); $this/* comment here */->testThis(); $this ->testThis(); $this-> testThis(); // phpcs:set Squiz.WhiteSpace.ObjectOperatorSpacing ignoreNewlines false thisObject::testThis(); thisObject::testThis(); thisObject::testThis(); thisObject::/* comment here */testThis(); thisObject/* comment here */::testThis(); thisObject::testThis(); thisObject::testThis(); // phpcs:set Squiz.WhiteSpace.ObjectOperatorSpacing ignoreNewlines true thisObject::testThis(); thisObject::testThis(); thisObject::testThis(); thisObject::/* comment here */testThis(); thisObject/* comment here */::testThis(); thisObject ::testThis(); thisObject:: testThis(); // phpcs:set Squiz.WhiteSpace.ObjectOperatorSpacing ignoreNewlines false PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/ObjectOperatorSpacingUnitTest.php0000644000076500000240000000303413614652362031740 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\WhiteSpace; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ObjectOperatorSpacingUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 3 => 1, 4 => 2, 5 => 1, 6 => 2, 8 => 1, 9 => 1, 15 => 1, 16 => 2, 18 => 2, 27 => 1, 28 => 2, 30 => 2, 32 => 1, 33 => 1, 39 => 1, 40 => 2, 42 => 2, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/OperatorSpacingUnitTest.inc0000644000076500000240000001563113614652362030601 0ustar gsherwoodstaff $j && $k< $l && $m>= $n && $o<= $p && $q<> $r; $a ==$b && $c !=$d && $e ===$f && $g !==$h; $i >$j && $k <$l && $m >=$n && $o <=$p && $q <>$r; function myFunction($variable=0, $var2='string') {} if (index > -1) { } array_walk_recursive($array, function(&$item) use (&$something) { }); $var = saveFile(&$model, &$foo); // This is all valid. $boo = -$foo; function foo($boo = -1) {} $foo = array('boo' => -1); $x = $test ? -1 : 1; $y = $test ? 1 : -1; $z = $test ?: false; $closureWithDefaultParameter = function (array $testArray=array()) {}; switch ($foo) { case -1: break; } $y = 1 * -1; $y = -1 * 1; $y = -1 * $var; $y = 10 / -2; $y = -10 / 2; $y = (-10 / 2); $y = (-10 / $var); $y = 10 + -2; $y = -10 + 2; $a = $x?$y:$z; $a = $x ? $y : $z; $y = 1 + 2 - 3; $y = 1 + 2 - 3; $y = 1 + 2 - 3; // phpcs:set Squiz.WhiteSpace.OperatorSpacing ignoreNewlines true $y = 1 + 2 - 3; $y = 1 + 2 - 3; $y = 1 + 2 - 3; // phpcs:set Squiz.WhiteSpace.OperatorSpacing ignoreNewlines false if (true || -1 == $b) { } $var = array(-1); $var = [-1]; $var = [0, -1, -2]; $y = array(&$x); $y = [&$x]; $y = array(&$a, &$b, &$c); $y = [&$a, &$b, &$c]; $y = array(&$a => 1, 2 => &$b, &$c); $y = [&$a => 1, 2 => &$b, &$c]; if ($a <=> $b) { } if ($a <=>$b) { } $a |= $b; $a **= $b; $a ??= $b; $a = +1; function bar($boo = +1) {} $username = $_GET['user']??'nobody'; function foo(string $bar, array $baz, ?MyClass $object) : MyClass {} declare(strict_types=1); function foo($c = ((BAR)?10:100)) {} $res = $a ?: $b; $res = $a ?: $b; $res = $a ?: $b; $res = $a ?: $b; $res = $a ? : $b; $res = $a ? : $b; $res = $a ? : $b; $res = $a ? : $b; function foo(string $a = '', ?string $b = ''): ?string {} // Issue #1605. $text = preg_replace_callback( self::CHAR_REFS_REGEX, [ 'Sanitizer', 'decodeCharReferencesCallback' ], $text, /* limit */ -1, $count ); if (true || /* test */ -1 == $b) {} $y = 10 + /* test */ -2; // Issue #1604. Hooks::run( 'ParserOptionsRegister', [ &self::$defaults, &self::$inCacheKey, &self::$lazyOptions, ] ); $x = $foo ? function (): int { return 1; } : $bar; $x = $foo ? function ($foo) // comment : int { return 1; } : $bar; $x = $foo ? function ($foo) use /* comment */ ($bar): int { return 1; } : $bar; $x = !$foo ? $bar : function (): int { return 1; }; $a = // Comment. [ 'a', 'b', ]; $a = // phpcs:ignore Standard.Category.Sniff -- for reasons. [ 'a', 'b', ]; $foo = is_array($bar) ? array_map( function () {}, $bar ) : $bar; function bar(): array {} if ($line{-1} === ':') { $line = substr($line, 0, -1); } $a = $a instanceof $b; $a = $a instanceof $b; $a = ($a)instanceof$b; fn&($x) => $x; // phpcs:set Squiz.WhiteSpace.OperatorSpacing ignoreSpacingBeforeAssignments false $a = 3; yield -1; echo -1; $a = -1; func(-1); $a = [-1]; return -1; print -1; $a &= -1; switch ($a) { case -1: } $a = $a ?? -1; $a .= -1; $a /= -1; $a = [1 => -1]; $a = $a == -1; $a = $a >= -1; $a = $a === -1; $a = $a != -1; $a = $a !== -1; $a = $a <= -1; $a = $a <=> -1; $a = $a and -1; $a = $a or -1; $a = $a xor -1; $a -= -1; $a %= -1; $a *= -1; $a |= -1; $a += -1; $a = $a ** -1; $a **= -1; $a = $a << -1; $a <<= -1; $a = $a >> -1; $a >>= -1; $a = (string) -1; $a = (array) -1; $a = (bool) -1; $a = (object) -1; $a = (unset) -1; $a = (float) -1; $a = (int) -1; $a ^= -1; $a = [$a, -1]; $a = $a[-1]; $a = $a ? -1 : -1; yield - 1; echo - 1; $a = - 1; func(- 1); $a = [- 1]; return - 1; print - 1; $a &= - 1; switch ($a) { case - 1: } $a = $a ?? - 1; $a .= - 1; $a /= - 1; $a = [1 => - 1]; $a = $a == - 1; $a = $a >= - 1; $a = $a === - 1; $a = $a != - 1; $a = $a !== - 1; $a = $a <= - 1; $a = $a <=> - 1; $a = $a and - 1; $a = $a or - 1; $a = $a xor - 1; $a -= - 1; $a %= - 1; $a *= - 1; $a |= - 1; $a += - 1; $a = $a ** - 1; $a **= - 1; $a = $a << - 1; $a <<= - 1; $a = $a >> - 1; $a >>= - 1; $a = (string) - 1; $a = (array) - 1; $a = (bool) - 1; $a = (object) - 1; $a = (unset) - 1; $a = (float) - 1; $a = (int) - 1; $a ^= - 1; $a = [$a, - 1]; $a = $a[- 1]; $a = $a ? - 1 : - 1; yield -$b; echo -$b; $a = -$b; func(-$b); $a = [-$b]; return -$b; print -$b; $a &= -$b; switch ($a) { case -$b: } $a = $a ?? -$b; $a .= -$b; $a /= -$b; $a = [1 => -$b]; $a = $a == -$b; $a = $a >= -$b; $a = $a === -$b; $a = $a != -$b; $a = $a !== -$b; $a = $a <= -$b; $a = $a <=> -$b; $a = $a and -$b; $a = $a or -$b; $a = $a xor -$b; $a -= -$b; $a %= -$b; $a *= -$b; $a |= -$b; $a += -$b; $a = $a ** -$b; $a **= -$b; $a = $a << -$b; $a <<= -$b; $a = $a >> -$b; $a >>= -$b; $a = (string) -$b; $a = (array) -$b; $a = (bool) -$b; $a = (object) -$b; $a = (unset) -$b; $a = (float) -$b; $a = (int) -$b; $a ^= -$b; $a = [$a, -$b]; $a = $a[-$b]; $a = $a ? -$b : -$b; yield - $b; echo - $b; $a = - $b; func(- $b); $a = [- $b]; return - $b; print - $b; $a &= - $b; switch ($a) { case - $b: } $a = $a ?? - $b; $a .= - $b; $a /= - $b; $a = [1 => - $b]; $a = $a == - $b; $a = $a >= - $b; $a = $a === - $b; $a = $a != - $b; $a = $a !== - $b; $a = $a <= - $b; $a = $a <=> - $b; $a = $a and - $b; $a = $a or - $b; $a = $a xor - $b; $a -= - $b; $a %= - $b; $a *= - $b; $a |= - $b; $a += - $b; $a = $a ** - $b; $a **= - $b; $a = $a << - $b; $a <<= - $b; $a = $a >> - $b; $a >>= - $b; $a = (string) - $b; $a = (array) - $b; $a = (bool) - $b; $a = (object) - $b; $a = (unset) - $b; $a = (float) - $b; $a = (int) - $b; $a ^= - $b; $a = [$a, - $b]; $a = $a[- $b]; $a = $a ? - $b : - $b; /* Intentional parse error. This has to be the last test in the file. */ $a = 10 + PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/OperatorSpacingUnitTest.inc.fixed0000644000076500000240000001566113614652362031702 0ustar gsherwoodstaff $j && $k < $l && $m >= $n && $o <= $p && $q <> $r; $a == $b && $c != $d && $e === $f && $g !== $h; $i > $j && $k < $l && $m >= $n && $o <= $p && $q <> $r; function myFunction($variable=0, $var2='string') {} if (index > -1) { } array_walk_recursive($array, function(&$item) use (&$something) { }); $var = saveFile(&$model, &$foo); // This is all valid. $boo = -$foo; function foo($boo = -1) {} $foo = array('boo' => -1); $x = $test ? -1 : 1; $y = $test ? 1 : -1; $z = $test ?: false; $closureWithDefaultParameter = function (array $testArray=array()) {}; switch ($foo) { case -1: break; } $y = 1 * -1; $y = -1 * 1; $y = -1 * $var; $y = 10 / -2; $y = -10 / 2; $y = (-10 / 2); $y = (-10 / $var); $y = 10 + -2; $y = -10 + 2; $a = $x ? $y : $z; $a = $x ? $y : $z; $y = 1 + 2 - 3; $y = 1 + 2 - 3; $y = 1 + 2 - 3; // phpcs:set Squiz.WhiteSpace.OperatorSpacing ignoreNewlines true $y = 1 + 2 - 3; $y = 1 + 2 - 3; $y = 1 + 2 - 3; // phpcs:set Squiz.WhiteSpace.OperatorSpacing ignoreNewlines false if (true || -1 == $b) { } $var = array(-1); $var = [-1]; $var = [0, -1, -2]; $y = array(&$x); $y = [&$x]; $y = array(&$a, &$b, &$c); $y = [&$a, &$b, &$c]; $y = array(&$a => 1, 2 => &$b, &$c); $y = [&$a => 1, 2 => &$b, &$c]; if ($a <=> $b) { } if ($a <=> $b) { } $a |= $b; $a **= $b; $a ??= $b; $a = +1; function bar($boo = +1) {} $username = $_GET['user'] ?? 'nobody'; function foo(string $bar, array $baz, ?MyClass $object) : MyClass {} declare(strict_types=1); function foo($c = ((BAR) ? 10 : 100)) {} $res = $a ?: $b; $res = $a ?: $b; $res = $a ?: $b; $res = $a ?: $b; $res = $a ? : $b; $res = $a ? : $b; $res = $a ? : $b; $res = $a ? : $b; function foo(string $a = '', ?string $b = ''): ?string {} // Issue #1605. $text = preg_replace_callback( self::CHAR_REFS_REGEX, [ 'Sanitizer', 'decodeCharReferencesCallback' ], $text, /* limit */ -1, $count ); if (true || /* test */ -1 == $b) {} $y = 10 + /* test */ -2; // Issue #1604. Hooks::run( 'ParserOptionsRegister', [ &self::$defaults, &self::$inCacheKey, &self::$lazyOptions, ] ); $x = $foo ? function (): int { return 1; } : $bar; $x = $foo ? function ($foo) // comment : int { return 1; } : $bar; $x = $foo ? function ($foo) use /* comment */ ($bar): int { return 1; } : $bar; $x = !$foo ? $bar : function (): int { return 1; }; $a = // Comment. [ 'a', 'b', ]; $a = // phpcs:ignore Standard.Category.Sniff -- for reasons. [ 'a', 'b', ]; $foo = is_array($bar) ? array_map( function () {}, $bar ) : $bar; function bar(): array {} if ($line{-1} === ':') { $line = substr($line, 0, -1); } $a = $a instanceof $b; $a = $a instanceof $b; $a = ($a) instanceof $b; fn&($x) => $x; // phpcs:set Squiz.WhiteSpace.OperatorSpacing ignoreSpacingBeforeAssignments false $a = 3; yield -1; echo -1; $a = -1; func(-1); $a = [-1]; return -1; print -1; $a &= -1; switch ($a) { case -1: } $a = $a ?? -1; $a .= -1; $a /= -1; $a = [1 => -1]; $a = $a == -1; $a = $a >= -1; $a = $a === -1; $a = $a != -1; $a = $a !== -1; $a = $a <= -1; $a = $a <=> -1; $a = $a and -1; $a = $a or -1; $a = $a xor -1; $a -= -1; $a %= -1; $a *= -1; $a |= -1; $a += -1; $a = $a ** -1; $a **= -1; $a = $a << -1; $a <<= -1; $a = $a >> -1; $a >>= -1; $a = (string) -1; $a = (array) -1; $a = (bool) -1; $a = (object) -1; $a = (unset) -1; $a = (float) -1; $a = (int) -1; $a ^= -1; $a = [$a, -1]; $a = $a[-1]; $a = $a ? -1 : -1; yield - 1; echo - 1; $a = - 1; func(- 1); $a = [- 1]; return - 1; print - 1; $a &= - 1; switch ($a) { case - 1: } $a = $a ?? - 1; $a .= - 1; $a /= - 1; $a = [1 => - 1]; $a = $a == - 1; $a = $a >= - 1; $a = $a === - 1; $a = $a != - 1; $a = $a !== - 1; $a = $a <= - 1; $a = $a <=> - 1; $a = $a and - 1; $a = $a or - 1; $a = $a xor - 1; $a -= - 1; $a %= - 1; $a *= - 1; $a |= - 1; $a += - 1; $a = $a ** - 1; $a **= - 1; $a = $a << - 1; $a <<= - 1; $a = $a >> - 1; $a >>= - 1; $a = (string) - 1; $a = (array) - 1; $a = (bool) - 1; $a = (object) - 1; $a = (unset) - 1; $a = (float) - 1; $a = (int) - 1; $a ^= - 1; $a = [$a, - 1]; $a = $a[- 1]; $a = $a ? - 1 : - 1; yield -$b; echo -$b; $a = -$b; func(-$b); $a = [-$b]; return -$b; print -$b; $a &= -$b; switch ($a) { case -$b: } $a = $a ?? -$b; $a .= -$b; $a /= -$b; $a = [1 => -$b]; $a = $a == -$b; $a = $a >= -$b; $a = $a === -$b; $a = $a != -$b; $a = $a !== -$b; $a = $a <= -$b; $a = $a <=> -$b; $a = $a and -$b; $a = $a or -$b; $a = $a xor -$b; $a -= -$b; $a %= -$b; $a *= -$b; $a |= -$b; $a += -$b; $a = $a ** -$b; $a **= -$b; $a = $a << -$b; $a <<= -$b; $a = $a >> -$b; $a >>= -$b; $a = (string) -$b; $a = (array) -$b; $a = (bool) -$b; $a = (object) -$b; $a = (unset) -$b; $a = (float) -$b; $a = (int) -$b; $a ^= -$b; $a = [$a, -$b]; $a = $a[-$b]; $a = $a ? -$b : -$b; yield - $b; echo - $b; $a = - $b; func(- $b); $a = [- $b]; return - $b; print - $b; $a &= - $b; switch ($a) { case - $b: } $a = $a ?? - $b; $a .= - $b; $a /= - $b; $a = [1 => - $b]; $a = $a == - $b; $a = $a >= - $b; $a = $a === - $b; $a = $a != - $b; $a = $a !== - $b; $a = $a <= - $b; $a = $a <=> - $b; $a = $a and - $b; $a = $a or - $b; $a = $a xor - $b; $a -= - $b; $a %= - $b; $a *= - $b; $a |= - $b; $a += - $b; $a = $a ** - $b; $a **= - $b; $a = $a << - $b; $a <<= - $b; $a = $a >> - $b; $a >>= - $b; $a = (string) - $b; $a = (array) - $b; $a = (bool) - $b; $a = (object) - $b; $a = (unset) - $b; $a = (float) - $b; $a = (int) - $b; $a ^= - $b; $a = [$a, - $b]; $a = $a[- $b]; $a = $a ? - $b : - $b; /* Intentional parse error. This has to be the last test in the file. */ $a = 10 + PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/OperatorSpacingUnitTest.js0000644000076500000240000000236713614652362030446 0ustar gsherwoodstaff result = 1 + 2; result = 1 + 2; result = 1 + 2; result = 1 +2; result = 1+ 2; result = 1+2; result = 1 - 2; result = 1 - 2; result = 1 - 2; result = 1 -2; result = 1- 2; result = 1-2; result = 1 * 2; result = 1 * 2; result = 1 * 2; result = 1 *2; result = 1* 2; result = 1*2; result = 1 / 2; result = 1 / 2; result = 1 / 2; result = 1 /2; result = 1/ 2; result = 1/2; result = 1 % 2; result = 1 % 2; result = 1 % 2; result = 1 %2; result = 1% 2; result = 1%2; result = '100%'; result += 4; result+=4; result -= 4; result-=4; result /= 4; result/=4; result *=4; result*=4; $.localScroll({offset: {top: -32}}); switch (result) { case -1: break; } result = x?y:z; result = x ? y : z; if (something === true ^ somethingElse === true ) { return false; } y = 1 + 2 - 3; y = 1 + 2 - 3; y = 1 + 2 - 3; // phpcs:set Squiz.WhiteSpace.OperatorSpacing ignoreNewlines true y = 1 + 2 - 3; y = 1 + 2 - 3; y = 1 + 2 - 3; // phpcs:set Squiz.WhiteSpace.OperatorSpacing ignoreNewlines false if (true || -1 == b) { } x = x << y; x <<= y; x = x >> y; x >>= y; x = x >>> y; x >>>= y; var foo = bar.map(baz=> baz.length); // phpcs:set Squiz.WhiteSpace.OperatorSpacing ignoreSpacingBeforeAssignments false a = 3; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/OperatorSpacingUnitTest.js.fixed0000644000076500000240000000236313614652362031540 0ustar gsherwoodstaff result = 1 + 2; result = 1 + 2; result = 1 + 2; result = 1 + 2; result = 1 + 2; result = 1 + 2; result = 1 - 2; result = 1 - 2; result = 1 - 2; result = 1 - 2; result = 1 - 2; result = 1 - 2; result = 1 * 2; result = 1 * 2; result = 1 * 2; result = 1 * 2; result = 1 * 2; result = 1 * 2; result = 1 / 2; result = 1 / 2; result = 1 / 2; result = 1 / 2; result = 1 / 2; result = 1 / 2; result = 1 % 2; result = 1 % 2; result = 1 % 2; result = 1 % 2; result = 1 % 2; result = 1 % 2; result = '100%'; result += 4; result += 4; result -= 4; result -= 4; result /= 4; result /= 4; result *= 4; result *= 4; $.localScroll({offset: {top: -32}}); switch (result) { case -1: break; } result = x ? y : z; result = x ? y : z; if (something === true ^ somethingElse === true ) { return false; } y = 1 + 2 - 3; y = 1 + 2 - 3; y = 1 + 2 - 3; // phpcs:set Squiz.WhiteSpace.OperatorSpacing ignoreNewlines true y = 1 + 2 - 3; y = 1 + 2 - 3; y = 1 + 2 - 3; // phpcs:set Squiz.WhiteSpace.OperatorSpacing ignoreNewlines false if (true || -1 == b) { } x = x << y; x <<= y; x = x >> y; x >>= y; x = x >>> y; x >>>= y; var foo = bar.map(baz => baz.length); // phpcs:set Squiz.WhiteSpace.OperatorSpacing ignoreSpacingBeforeAssignments false a = 3; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/OperatorSpacingUnitTest.php0000644000076500000240000001045313614652362030614 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\WhiteSpace; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class OperatorSpacingUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='OperatorSpacingUnitTest.inc') { switch ($testFile) { case 'OperatorSpacingUnitTest.inc': return [ 4 => 1, 5 => 2, 6 => 1, 7 => 1, 8 => 2, 11 => 1, 12 => 2, 13 => 1, 14 => 1, 15 => 2, 18 => 1, 19 => 2, 20 => 1, 21 => 1, 22 => 2, 25 => 1, 26 => 2, 27 => 1, 28 => 1, 29 => 2, 32 => 1, 33 => 2, 34 => 1, 35 => 1, 36 => 2, 40 => 2, 42 => 2, 44 => 2, 45 => 1, 46 => 2, 53 => 4, 54 => 3, 59 => 10, 64 => 1, 77 => 4, 78 => 1, 79 => 1, 80 => 2, 81 => 1, 84 => 6, 85 => 6, 87 => 4, 88 => 5, 90 => 4, 91 => 5, 128 => 4, 132 => 1, 133 => 1, 135 => 1, 136 => 1, 140 => 1, 141 => 1, 174 => 1, 177 => 1, 178 => 1, 179 => 1, 185 => 2, 191 => 4, 194 => 1, 195 => 1, 196 => 2, 199 => 1, 200 => 1, 201 => 2, 239 => 1, 246 => 1, 265 => 2, 266 => 2, 271 => 2, ]; break; case 'OperatorSpacingUnitTest.js': return [ 4 => 1, 5 => 2, 6 => 1, 7 => 1, 8 => 2, 11 => 1, 12 => 2, 13 => 1, 14 => 1, 15 => 2, 18 => 1, 19 => 2, 20 => 1, 21 => 1, 22 => 2, 25 => 1, 26 => 2, 27 => 1, 28 => 1, 29 => 2, 32 => 1, 33 => 2, 34 => 1, 35 => 1, 36 => 2, 40 => 2, 42 => 2, 44 => 2, 45 => 1, 46 => 2, 55 => 4, 65 => 1, 66 => 1, 68 => 1, 69 => 1, 73 => 1, 74 => 1, 100 => 1, 103 => 2, ]; break; default: return []; break; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/PropertyLabelSpacingUnitTest.js0000644000076500000240000000111213614652362031422 0ustar gsherwoodstaffvar x = { b: 'x', xasd: x, abc:x, a: function () { alert('thats right'); x = (x?a:x); }, casdasd : 123123, omgwtfbbq: { a: 1, b: 2 } }; id = id.replace(/row\/:/gi, ''); outer_loop: for (i=0; i<3; i++) { for (j=0; j<5; j++) { if (j==x) break outer_loop; } } alert('hi'); even_number: if ((i % 2) == 0) { if (i == 12) break even_number; } switch (blah) { case dfx.DOM_VK_LEFT: this.caretLeft(shiftKey); break; default: if (blah) { } break; } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/PropertyLabelSpacingUnitTest.js.fixed0000644000076500000240000000110513614652362032522 0ustar gsherwoodstaffvar x = { b: 'x', xasd: x, abc: x, a: function () { alert('thats right'); x = (x?a:x); }, casdasd: 123123, omgwtfbbq: { a: 1, b: 2 } }; id = id.replace(/row\/:/gi, ''); outer_loop: for (i=0; i<3; i++) { for (j=0; j<5; j++) { if (j==x) break outer_loop; } } alert('hi'); even_number: if ((i % 2) == 0) { if (i == 12) break even_number; } switch (blah) { case dfx.DOM_VK_LEFT: this.caretLeft(shiftKey); break; default: if (blah) { } break; } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/PropertyLabelSpacingUnitTest.php0000644000076500000240000000245413614652362031607 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\WhiteSpace; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class PropertyLabelSpacingUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 2 => 1, 4 => 1, 9 => 2, 10 => 1, 12 => 1, 18 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/ScopeClosingBraceUnitTest.inc0000644000076500000240000000276413614652362031031 0ustar gsherwoodstaff{$property} =& new $class_name($this->db_index); $this->modules[$module] =& $this->{$property}; } foreach ($elements as $element) { if ($something) { // Do IF. } else if ($somethingElse) { // Do ELSE. } } if ($token['code'] === T_COMMENT && $multiLineComment === false && (substr($token['content'], 0, 2) === '//' || $token['content']{0} === '#') ) { } switch ($blah) { case 'one': echo 'one'; break; default: echo 'another'; } ?> getRow()): ?>

    o hai!

    $x + $y; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/ScopeClosingBraceUnitTest.inc.fixed0000644000076500000240000000276713614652362032132 0ustar gsherwoodstaff{$property} =& new $class_name($this->db_index); $this->modules[$module] =& $this->{$property}; } foreach ($elements as $element) { if ($something) { // Do IF. } else if ($somethingElse) { // Do ELSE. } } if ($token['code'] === T_COMMENT && $multiLineComment === false && (substr($token['content'], 0, 2) === '//' || $token['content']{0} === '#') ) { } switch ($blah) { case 'one': echo 'one'; break; default: echo 'another'; } ?> getRow()): ?>

    o hai!

    $x + $y; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/ScopeClosingBraceUnitTest.php0000644000076500000240000000243513614652362031042 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\WhiteSpace; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ScopeClosingBraceUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 11 => 1, 13 => 1, 24 => 1, 80 => 1, 102 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/ScopeKeywordSpacingUnitTest.inc0000644000076500000240000000266013614652362031422 0ustar gsherwoodstaff 'a', 'b' => 'b' ), $varQ = 'string', $varR = 123; // Intentionally missing a semi-colon for testing. public $varS, $varT } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/ScopeKeywordSpacingUnitTest.inc.fixed0000644000076500000240000000260213614652362032514 0ustar gsherwoodstaff 'a', 'b' => 'b' ), $varQ = 'string', $varR = 123; // Intentionally missing a semi-colon for testing. public $varS, $varT } PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/ScopeKeywordSpacingUnitTest.php0000644000076500000240000000265713614652362031446 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\WhiteSpace; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ScopeKeywordSpacingUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 7 => 2, 8 => 1, 13 => 1, 14 => 1, 15 => 1, 17 => 2, 26 => 1, 28 => 1, 29 => 1, 64 => 1, 67 => 1, 71 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SemicolonSpacingUnitTest.inc0000644000076500000240000000140413614652362030727 0ustar gsherwoodstafftestThis(); $test = $this->testThis() ; $test = $this->testThis() ; for ($var = 1 ; $var < 10 ; $var++) { echo $var ; } $test = $this->testThis() /* comment here */; $test = $this->testThis() /* comment here */ ; $hello ='foo'; ; $sum = $a /* + $b */; $sum = $a // + $b ; $sum = $a /* + $b + $c */ ; /* * Test that the sniff does *not* throw incorrect errors for semi-colons in * "empty" parts of a `for` control structure. */ for ($i = 1; ; $i++) {} for ( ; $ptr >= 0; $ptr-- ) {} for ( ; ; ) {} // But it should when the semi-colon in a `for` follows a comment (but shouldn't move the semi-colon). for ( /* Deliberately left empty. */ ; $ptr >= 0; $ptr-- ) {} for ( $i = 1 ; /* Deliberately left empty. */ ; $i++ ) {} PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SemicolonSpacingUnitTest.inc.fixed0000644000076500000240000000135413614652362032031 0ustar gsherwoodstafftestThis(); $test = $this->testThis(); $test = $this->testThis(); for ($var = 1; $var < 10; $var++) { echo $var; } $test = $this->testThis(); /* comment here */ $test = $this->testThis(); /* comment here */ $hello ='foo'; ; $sum = $a; /* + $b */ $sum = $a; // + $b $sum = $a; /* + $b + $c */ /* * Test that the sniff does *not* throw incorrect errors for semi-colons in * "empty" parts of a `for` control structure. */ for ($i = 1; ; $i++) {} for ( ; $ptr >= 0; $ptr-- ) {} for ( ; ; ) {} // But it should when the semi-colon in a `for` follows a comment (but shouldn't move the semi-colon). for ( /* Deliberately left empty. */; $ptr >= 0; $ptr-- ) {} for ( $i = 1; /* Deliberately left empty. */; $i++ ) {} PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SemicolonSpacingUnitTest.js0000644000076500000240000000047413614652362030600 0ustar gsherwoodstaffvar x = { a: function () { alert('thats right') ; x = (x?a:x) ; }, } ; id = id.replace(/row\/:;/gi, ''); for (i=0 ; i<3 ; i++) { for (j=0; j<5 ; j++) { if (j==x) break ; } } alert('hi'); ; var sum = a /* + b */; var sum = a // +b ; var sum = a /* +b + c */ ; PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SemicolonSpacingUnitTest.js.fixed0000644000076500000240000000046113614652362031672 0ustar gsherwoodstaffvar x = { a: function () { alert('thats right'); x = (x?a:x); }, }; id = id.replace(/row\/:;/gi, ''); for (i=0; i<3; i++) { for (j=0; j<5; j++) { if (j==x) break; } } alert('hi'); ; var sum = a; /* + b */ var sum = a; // +b var sum = a; /* +b + c */ PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SemicolonSpacingUnitTest.php0000644000076500000240000000405313614652362030750 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\WhiteSpace; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class SemicolonSpacingUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='SemicolonSpacingUnitTest.inc') { switch ($testFile) { case 'SemicolonSpacingUnitTest.inc': return [ 3 => 1, 4 => 1, 5 => 2, 6 => 1, 8 => 1, 9 => 1, 14 => 1, 16 => 1, 18 => 1, 29 => 1, 30 => 2, ]; break; case 'SemicolonSpacingUnitTest.js': return [ 3 => 1, 4 => 1, 6 => 1, 10 => 2, 11 => 1, 13 => 1, 19 => 1, 22 => 1, 25 => 1, ]; break; default: return []; break; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.1.inc0000644000076500000240000000175113614652362032207 0ustar gsherwoodstaff ././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.1.inc.fixedPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.1.inc.fixed0000644000076500000240000000171013614652362033300 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.2.inc0000644000076500000240000000024513614652362032205 0ustar gsherwoodstaff

    ././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.2.inc.fixedPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.2.inc.fixed0000644000076500000240000000024313614652362033301 0ustar gsherwoodstaff

    PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.3.inc0000644000076500000240000000017013614652362032203 0ustar gsherwoodstaff ././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.3.inc.fixedPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.3.inc.fixed0000644000076500000240000000011313614652362033276 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.4.inc0000644000076500000240000000015113614652362032203 0ustar gsherwoodstaff ././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.4.inc.fixedPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.4.inc.fixed0000644000076500000240000000014613614652362033305 0ustar gsherwoodstaffPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.5.inc0000644000076500000240000000014313614652362032205 0ustar gsherwoodstaff    ././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.5.inc.fixedPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.5.inc.fixed0000644000076500000240000000013413614652362033303 0ustar gsherwoodstaffPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.1.css0000644000076500000240000000073713614652362032231 0ustar gsherwoodstaff .HelpWidgetType-new-bug-title { float: left; } .HelpWidgetType-new-bug-title { float: left; } .HelpWidgetType-new-bug-title { float: left; } .HelpWidgetType-new-bug-title{ float: left; } /* phpcs:set Squiz.WhiteSpace.SuperfluousWhitespace ignoreBlankLines true */ .HelpWidgetType-new-bug-title{ float: left; } .HelpWidgetType-new-bug-title{ float: left; } /* phpcs:set Squiz.WhiteSpace.SuperfluousWhitespace ignoreBlankLines false */ ././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.1.css.fixedPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.1.css.fixed0000644000076500000240000000072313614652362033322 0ustar gsherwoodstaff.HelpWidgetType-new-bug-title { float: left; } .HelpWidgetType-new-bug-title { float: left; } .HelpWidgetType-new-bug-title { float: left; } .HelpWidgetType-new-bug-title{ float: left; } /* phpcs:set Squiz.WhiteSpace.SuperfluousWhitespace ignoreBlankLines true */ .HelpWidgetType-new-bug-title{ float: left; } .HelpWidgetType-new-bug-title{ float: left; } /* phpcs:set Squiz.WhiteSpace.SuperfluousWhitespace ignoreBlankLines false */ PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.1.js0000644000076500000240000000111013614652362032037 0ustar gsherwoodstaff alert('hi'); alert('hello'); if (something) { } function myFunction() { alert('code here'); alert('code here'); // Hello. /* HI */ } function myFunction2() { alert('code here'); alert('code here'); } MyFunction = function() { alert('code here'); alert('code here'); }; // phpcs:set Squiz.WhiteSpace.SuperfluousWhitespace ignoreBlankLines true function myFunction2() { alert('code here'); alert('code here'); } // phpcs:set Squiz.WhiteSpace.SuperfluousWhitespace ignoreBlankLines false PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.1.js.fixed0000644000076500000240000000106513614652362033146 0ustar gsherwoodstaffalert('hi'); alert('hello'); if (something) { } function myFunction() { alert('code here'); alert('code here'); // Hello. /* HI */ } function myFunction2() { alert('code here'); alert('code here'); } MyFunction = function() { alert('code here'); alert('code here'); }; // phpcs:set Squiz.WhiteSpace.SuperfluousWhitespace ignoreBlankLines true function myFunction2() { alert('code here'); alert('code here'); } // phpcs:set Squiz.WhiteSpace.SuperfluousWhitespace ignoreBlankLines false PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.2.css0000644000076500000240000000006213614652362032221 0ustar gsherwoodstaff.HelpWidgetType-new-bug-title { float: left; }././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.2.css.fixedPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.2.css.fixed0000644000076500000240000000006213614652362033317 0ustar gsherwoodstaff.HelpWidgetType-new-bug-title { float: left; }PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.2.js0000644000076500000240000000001413614652362032042 0ustar gsherwoodstaffalert('hi');PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.2.js.fixed0000644000076500000240000000001413614652362033140 0ustar gsherwoodstaffalert('hi');PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.3.css0000644000076500000240000000006313614652362032223 0ustar gsherwoodstaff.HelpWidgetType-new-bug-title { float: left; } ././@LongLink0000000000000000000000000000014400000000000007754 Lustar PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.3.css.fixedPHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.3.css.fixed0000644000076500000240000000006213614652362033320 0ustar gsherwoodstaff.HelpWidgetType-new-bug-title { float: left; }PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.3.js0000644000076500000240000000001513614652362032044 0ustar gsherwoodstaffalert('hi'); PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.3.js.fixed0000644000076500000240000000001513614652362033142 0ustar gsherwoodstaffalert('hi'); PHP_CodeSniffer-3.5.4/src/Standards/Squiz/Tests/WhiteSpace/SuperfluousWhitespaceUnitTest.php0000644000076500000240000000560213614652362032065 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Squiz\Tests\WhiteSpace; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class SuperfluousWhitespaceUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='SuperfluousWhitespaceUnitTest.inc') { switch ($testFile) { case 'SuperfluousWhitespaceUnitTest.1.inc': return [ 2 => 1, 4 => 1, 5 => 1, 6 => 1, 7 => 1, 16 => 1, 23 => 1, 28 => 1, 33 => 1, 49 => 1, 62 => 1, 65 => 1, 73 => 1, ]; break; case 'SuperfluousWhitespaceUnitTest.2.inc': return [ 2 => 1, 8 => 1, ]; break; case 'SuperfluousWhitespaceUnitTest.3.inc': return [ 6 => 1, 10 => 1, ]; break; case 'SuperfluousWhitespaceUnitTest.4.inc': case 'SuperfluousWhitespaceUnitTest.5.inc': return [ 1 => 1, 4 => 1, ]; break; case 'SuperfluousWhitespaceUnitTest.1.js': return [ 1 => 1, 3 => 1, 4 => 1, 5 => 1, 6 => 1, 15 => 1, 22 => 1, 29 => 1, 38 => 1, 56 => 1, ]; break; case 'SuperfluousWhitespaceUnitTest.1.css': return [ 1 => 1, 8 => 1, 9 => 1, 11 => 1, 25 => 1, ]; break; default: return []; break; }//end switch }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Squiz/ruleset.xml0000644000076500000240000001214313614652362022350 0ustar gsherwoodstaff The Squiz coding standard. 0 %2$s 0 0 0 0 0 0 error 0 error PHP_CodeSniffer-3.5.4/src/Standards/Zend/Docs/Debug/CodeAnalyzerStandard.xml0000644000076500000240000000103113614652362026423 0ustar gsherwoodstaff $bar + $baz; } ]]> $bar + 2; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Zend/Docs/Files/ClosingTagStandard.xml0000644000076500000240000000075313614652362026123 0ustar gsherwoodstaff ?> ]]> PHP_CodeSniffer-3.5.4/src/Standards/Zend/Docs/NamingConventions/ValidVariableNameStandard.xml0000644000076500000240000000175113614652362031773 0ustar gsherwoodstaff $testNumber = 1; ]]> $Test_Number = 1; ]]> _bar; } ]]> PHP_CodeSniffer-3.5.4/src/Standards/Zend/Sniffs/Debug/CodeAnalyzerSniff.php0000644000076500000240000000652313614652362026272 0ustar gsherwoodstaff * @author Greg Sherwood * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Zend\Sniffs\Debug; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Exceptions\RuntimeException; class CodeAnalyzerSniff implements Sniff { /** * Returns the token types that this sniff is interested in. * * @return int[] */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes the tokens that this sniff is interested in. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file where the token was found. * @param int $stackPtr The position in the stack where * the token was found. * * @return int * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If ZendCodeAnalyzer could not be run. */ public function process(File $phpcsFile, $stackPtr) { $analyzerPath = Config::getExecutablePath('zend_ca'); if ($analyzerPath === null) { return; } $fileName = $phpcsFile->getFilename(); // In the command, 2>&1 is important because the code analyzer sends its // findings to stderr. $output normally contains only stdout, so using 2>&1 // will pipe even stderr to stdout. $cmd = escapeshellcmd($analyzerPath).' '.escapeshellarg($fileName).' 2>&1'; // There is the possibility to pass "--ide" as an option to the analyzer. // This would result in an output format which would be easier to parse. // The problem here is that no cleartext error messages are returned; only // error-code-labels. So for a start we go for cleartext output. $exitCode = exec($cmd, $output, $retval); // Variable $exitCode is the last line of $output if no error occurs, on // error it is numeric. Try to handle various error conditions and // provide useful error reporting. if (is_numeric($exitCode) === true && $exitCode > 0) { if (is_array($output) === true) { $msg = join('\n', $output); } throw new RuntimeException("Failed invoking ZendCodeAnalyzer, exitcode was [$exitCode], retval was [$retval], output was [$msg]"); } if (is_array($output) === true) { foreach ($output as $finding) { // The first two lines of analyzer output contain // something like this: // > Zend Code Analyzer 1.2.2 // > Analyzing ... // So skip these... $res = preg_match("/^.+\(line ([0-9]+)\):(.+)$/", $finding, $regs); if (empty($regs) === true || $res === false) { continue; } $phpcsFile->addWarningOnLine(trim($regs[2]), $regs[1], 'ExternalTool'); } } // Ignore the rest of the file. return ($phpcsFile->numTokens + 1); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Zend/Sniffs/Files/ClosingTagSniff.php0000644000076500000240000000473313614652362025761 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Zend\Sniffs\Files; use PHP_CodeSniffer\Sniffs\Sniff; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Util\Tokens; class ClosingTagSniff implements Sniff { /** * Returns an array of tokens this test wants to listen for. * * @return array */ public function register() { return [T_OPEN_TAG]; }//end register() /** * Processes this sniff, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in * the stack passed in $tokens. * * @return void */ public function process(File $phpcsFile, $stackPtr) { // Find the last non-empty token. $tokens = $phpcsFile->getTokens(); for ($last = ($phpcsFile->numTokens - 1); $last > 0; $last--) { if (trim($tokens[$last]['content']) !== '') { break; } } if ($tokens[$last]['code'] === T_CLOSE_TAG) { $error = 'A closing tag is not permitted at the end of a PHP file'; $fix = $phpcsFile->addFixableError($error, $last, 'NotAllowed'); if ($fix === true) { $phpcsFile->fixer->beginChangeset(); $phpcsFile->fixer->replaceToken($last, $phpcsFile->eolChar); $prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($last - 1), null, true); if ($tokens[$prev]['code'] !== T_SEMICOLON && $tokens[$prev]['code'] !== T_CLOSE_CURLY_BRACKET && $tokens[$prev]['code'] !== T_OPEN_TAG ) { $phpcsFile->fixer->addContent($prev, ';'); } $phpcsFile->fixer->endChangeset(); } $phpcsFile->recordMetric($stackPtr, 'PHP closing tag at EOF', 'yes'); } else { $phpcsFile->recordMetric($stackPtr, 'PHP closing tag at EOF', 'no'); }//end if // Ignore the rest of the file. return ($phpcsFile->numTokens + 1); }//end process() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Zend/Sniffs/NamingConventions/ValidVariableNameSniff.php0000644000076500000240000002011113614652362031616 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Zend\Sniffs\NamingConventions; use PHP_CodeSniffer\Sniffs\AbstractVariableSniff; use PHP_CodeSniffer\Util\Common; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Util\Tokens; class ValidVariableNameSniff extends AbstractVariableSniff { /** * Processes this test, when one of its tokens is encountered. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ protected function processVariable(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $varName = ltrim($tokens[$stackPtr]['content'], '$'); // If it's a php reserved var, then its ok. if (isset($this->phpReservedVars[$varName]) === true) { return; } $objOperator = $phpcsFile->findNext([T_WHITESPACE], ($stackPtr + 1), null, true); if ($tokens[$objOperator]['code'] === T_OBJECT_OPERATOR) { // Check to see if we are using a variable from an object. $var = $phpcsFile->findNext([T_WHITESPACE], ($objOperator + 1), null, true); if ($tokens[$var]['code'] === T_STRING) { // Either a var name or a function call, so check for bracket. $bracket = $phpcsFile->findNext([T_WHITESPACE], ($var + 1), null, true); if ($tokens[$bracket]['code'] !== T_OPEN_PARENTHESIS) { $objVarName = $tokens[$var]['content']; // There is no way for us to know if the var is public or private, // so we have to ignore a leading underscore if there is one and just // check the main part of the variable name. $originalVarName = $objVarName; if (substr($objVarName, 0, 1) === '_') { $objVarName = substr($objVarName, 1); } if (Common::isCamelCaps($objVarName, false, true, false) === false) { $error = 'Variable "%s" is not in valid camel caps format'; $data = [$originalVarName]; $phpcsFile->addError($error, $var, 'NotCamelCaps', $data); } else if (preg_match('|\d|', $objVarName) === 1) { $warning = 'Variable "%s" contains numbers but this is discouraged'; $data = [$originalVarName]; $phpcsFile->addWarning($warning, $stackPtr, 'ContainsNumbers', $data); } }//end if }//end if }//end if // There is no way for us to know if the var is public or private, // so we have to ignore a leading underscore if there is one and just // check the main part of the variable name. $originalVarName = $varName; if (substr($varName, 0, 1) === '_') { $objOperator = $phpcsFile->findPrevious([T_WHITESPACE], ($stackPtr - 1), null, true); if ($tokens[$objOperator]['code'] === T_DOUBLE_COLON) { // The variable lives within a class, and is referenced like // this: MyClass::$_variable, so we don't know its scope. $inClass = true; } else { $inClass = $phpcsFile->hasCondition($stackPtr, Tokens::$ooScopeTokens); } if ($inClass === true) { $varName = substr($varName, 1); } } if (Common::isCamelCaps($varName, false, true, false) === false) { $error = 'Variable "%s" is not in valid camel caps format'; $data = [$originalVarName]; $phpcsFile->addError($error, $stackPtr, 'NotCamelCaps', $data); } else if (preg_match('|\d|', $varName) === 1) { $warning = 'Variable "%s" contains numbers but this is discouraged'; $data = [$originalVarName]; $phpcsFile->addWarning($warning, $stackPtr, 'ContainsNumbers', $data); } }//end processVariable() /** * Processes class member variables. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the current token in the * stack passed in $tokens. * * @return void */ protected function processMemberVar(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); $varName = ltrim($tokens[$stackPtr]['content'], '$'); $memberProps = $phpcsFile->getMemberProperties($stackPtr); if (empty($memberProps) === true) { // Exception encountered. return; } $public = ($memberProps['scope'] === 'public'); if ($public === true) { if (substr($varName, 0, 1) === '_') { $error = 'Public member variable "%s" must not contain a leading underscore'; $data = [$varName]; $phpcsFile->addError($error, $stackPtr, 'PublicHasUnderscore', $data); } } else { if (substr($varName, 0, 1) !== '_') { $scope = ucfirst($memberProps['scope']); $error = '%s member variable "%s" must contain a leading underscore'; $data = [ $scope, $varName, ]; $phpcsFile->addError($error, $stackPtr, 'PrivateNoUnderscore', $data); } } // Remove a potential underscore prefix for testing CamelCaps. $varName = ltrim($varName, '_'); if (Common::isCamelCaps($varName, false, true, false) === false) { $error = 'Member variable "%s" is not in valid camel caps format'; $data = [$varName]; $phpcsFile->addError($error, $stackPtr, 'MemberVarNotCamelCaps', $data); } else if (preg_match('|\d|', $varName) === 1) { $warning = 'Member variable "%s" contains numbers but this is discouraged'; $data = [$varName]; $phpcsFile->addWarning($warning, $stackPtr, 'MemberVarContainsNumbers', $data); } }//end processMemberVar() /** * Processes the variable found within a double quoted string. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned. * @param int $stackPtr The position of the double quoted * string. * * @return void */ protected function processVariableInString(File $phpcsFile, $stackPtr) { $tokens = $phpcsFile->getTokens(); if (preg_match_all('|[^\\\]\$([a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)|', $tokens[$stackPtr]['content'], $matches) !== 0) { foreach ($matches[1] as $varName) { // If it's a php reserved var, then its ok. if (isset($this->phpReservedVars[$varName]) === true) { continue; } if (Common::isCamelCaps($varName, false, true, false) === false) { $error = 'Variable "%s" is not in valid camel caps format'; $data = [$varName]; $phpcsFile->addError($error, $stackPtr, 'StringVarNotCamelCaps', $data); } else if (preg_match('|\d|', $varName) === 1) { $warning = 'Variable "%s" contains numbers but this is discouraged'; $data = [$varName]; $phpcsFile->addWarning($warning, $stackPtr, 'StringVarContainsNumbers', $data); } }//end foreach }//end if }//end processVariableInString() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Zend/Tests/Debug/CodeAnalyzerUnitTest.inc0000644000076500000240000000012713614652362026632 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Zend/Tests/Debug/CodeAnalyzerUnitTest.php0000644000076500000240000000300213614652362026643 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Zend\Tests\Debug; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; use PHP_CodeSniffer\Config; class CodeAnalyzerUnitTest extends AbstractSniffUnitTest { /** * Should this test be skipped for some reason. * * @return void */ protected function shouldSkipTest() { $analyzerPath = Config::getExecutablePath('zend_ca'); if ($analyzerPath === null) { return true; } return false; }//end shouldSkipTest() /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return []; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return [2 => 1]; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Zend/Tests/Files/ClosingTagUnitTest.1.inc0000644000076500000240000000005713614652362026461 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Zend/Tests/Files/ClosingTagUnitTest.1.inc.fixed0000644000076500000240000000005513614652362027555 0ustar gsherwoodstaff

    PHP_CodeSniffer-3.5.4/src/Standards/Zend/Tests/Files/ClosingTagUnitTest.3.inc0000644000076500000240000000004313614652362026456 0ustar gsherwoodstaffadd('arg'))?> PHP_CodeSniffer-3.5.4/src/Standards/Zend/Tests/Files/ClosingTagUnitTest.3.inc.fixed0000644000076500000240000000004213614652362027553 0ustar gsherwoodstaffadd('arg')); PHP_CodeSniffer-3.5.4/src/Standards/Zend/Tests/Files/ClosingTagUnitTest.4.inc0000644000076500000240000000006213614652362026460 0ustar gsherwoodstaffadd('arg')) /* comment */ ?> PHP_CodeSniffer-3.5.4/src/Standards/Zend/Tests/Files/ClosingTagUnitTest.4.inc.fixed0000644000076500000240000000006113614652362027555 0ustar gsherwoodstaffadd('arg')); /* comment */ PHP_CodeSniffer-3.5.4/src/Standards/Zend/Tests/Files/ClosingTagUnitTest.5.inc0000644000076500000240000000007013614652362026460 0ustar gsherwoodstaffadd('arg')); } ?> PHP_CodeSniffer-3.5.4/src/Standards/Zend/Tests/Files/ClosingTagUnitTest.5.inc.fixed0000644000076500000240000000006613614652362027563 0ustar gsherwoodstaffadd('arg')); } PHP_CodeSniffer-3.5.4/src/Standards/Zend/Tests/Files/ClosingTagUnitTest.6.inc0000644000076500000240000000002413614652362026460 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Zend/Tests/Files/ClosingTagUnitTest.6.inc.fixed0000644000076500000240000000002213614652362027554 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/src/Standards/Zend/Tests/Files/ClosingTagUnitTest.7.inc.fixed0000644000076500000240000000000713614652362027560 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Zend\Tests\Files; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ClosingTagUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @param string $testFile The name of the file being tested. * * @return array */ public function getErrorList($testFile='') { switch ($testFile) { case 'ClosingTagUnitTest.1.inc': return [11 => 1]; case 'ClosingTagUnitTest.3.inc': case 'ClosingTagUnitTest.4.inc': case 'ClosingTagUnitTest.5.inc': case 'ClosingTagUnitTest.7.inc': return [1 => 1]; case 'ClosingTagUnitTest.6.inc': return [3 => 1]; default: return []; } }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return []; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Zend/Tests/NamingConventions/ValidVariableNameUnitTest.inc0000644000076500000240000000465713614652362032205 0ustar gsherwoodstaffvarName; echo $this->var_name; echo $this->varname; echo $this->_varName; echo $this->varName2; echo $object->varName; echo $object->var_name; echo $object->varName2; echo $object_name->varname; echo $object_name->_varName; echo $object_name->varName2; echo $this->myFunction($one, $two); echo $object->myFunction($one_two, $var2); $error = "format is \$GLOBALS['$varName']"; $error = "format is \$GLOBALS['$varName2']"; echo $_SESSION['var_name']; echo $_FILES['var_name']; echo $_ENV['var_name']; echo $_COOKIE['var_name']; echo $_COOKIE['var_name2']; $XML = 'hello'; $myXML = 'hello'; $XMLParser = 'hello'; $xmlParser = 'hello'; $xmlParser2 = 'hello'; echo "{$_SERVER['HOSTNAME']} $var_name"; $someObject->{$name}; $someObject->my_function($var_name); var_dump($http_response_header); var_dump($HTTP_RAW_POST_DATA); var_dump($php_errormsg); interface Base { protected $anonymous; public function __construct(); } $anonClass = new class() { public function foo($foo, $_foo, $foo_bar) { $bar = 1; $_bar = 2; $bar_foo = 3; } }; PHP_CodeSniffer-3.5.4/src/Standards/Zend/Tests/NamingConventions/ValidVariableNameUnitTest.php0000644000076500000240000000416013614652362032210 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Standards\Zend\Tests\NamingConventions; use PHP_CodeSniffer\Tests\Standards\AbstractSniffUnitTest; class ValidVariableNameUnitTest extends AbstractSniffUnitTest { /** * Returns the lines where errors should occur. * * The key of the array should represent the line number and the value * should represent the number of errors that should occur on that line. * * @return array */ public function getErrorList() { return [ 3 => 1, 5 => 1, 11 => 1, 13 => 1, 17 => 1, 19 => 1, 23 => 1, 25 => 1, 29 => 1, 31 => 1, 36 => 1, 38 => 1, 42 => 1, 44 => 1, 48 => 1, 50 => 1, 61 => 1, 67 => 1, 72 => 1, 74 => 1, 75 => 1, 76 => 1, 79 => 1, 96 => 1, 99 => 1, 113 => 1, 116 => 1, ]; }//end getErrorList() /** * Returns the lines where warnings should occur. * * The key of the array should represent the line number and the value * should represent the number of warnings that should occur on that line. * * @return array */ public function getWarningList() { return [ 6 => 1, 14 => 1, 20 => 1, 26 => 1, 32 => 1, 39 => 1, 45 => 1, 51 => 1, 64 => 1, 70 => 1, 73 => 1, 76 => 1, 79 => 1, 82 => 1, 94 => 1, 107 => 1, ]; }//end getWarningList() }//end class PHP_CodeSniffer-3.5.4/src/Standards/Zend/ruleset.xml0000644000076500000240000000252613614652362022141 0ustar gsherwoodstaff A coding standard based on an early Zend Framework coding standard. Note that this standard is out of date. PHP_CodeSniffer-3.5.4/src/Tokenizers/Comment.php0000644000076500000240000002113313614652362021354 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tokenizers; use PHP_CodeSniffer\Util; class Comment { /** * Creates an array of tokens when given some PHP code. * * Starts by using token_get_all() but does a lot of extra processing * to insert information about the context of the token. * * @param string $string The string to tokenize. * @param string $eolChar The EOL character to use for splitting strings. * @param int $stackPtr The position of the first token in the file. * * @return array */ public function tokenizeString($string, $eolChar, $stackPtr) { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t*** START COMMENT TOKENIZING ***".PHP_EOL; } $tokens = []; $numChars = strlen($string); /* Doc block comments start with /*, but typically contain an extra star when they are used for function and class comments. */ $char = ($numChars - strlen(ltrim($string, '/*'))); $openTag = substr($string, 0, $char); $string = ltrim($string, '/*'); $tokens[$stackPtr] = [ 'content' => $openTag, 'code' => T_DOC_COMMENT_OPEN_TAG, 'type' => 'T_DOC_COMMENT_OPEN_TAG', 'comment_tags' => [], ]; $openPtr = $stackPtr; $stackPtr++; if (PHP_CODESNIFFER_VERBOSITY > 1) { $content = Util\Common::prepareForOutput($openTag); echo "\t\tCreate comment token: T_DOC_COMMENT_OPEN_TAG => $content".PHP_EOL; } /* Strip off the close tag so it doesn't interfere with any of our comment line processing. The token will be added to the stack just before we return it. */ $closeTag = [ 'content' => substr($string, strlen(rtrim($string, '/*'))), 'code' => T_DOC_COMMENT_CLOSE_TAG, 'type' => 'T_DOC_COMMENT_CLOSE_TAG', 'comment_opener' => $openPtr, ]; if ($closeTag['content'] === false) { $closeTag['content'] = ''; } $string = rtrim($string, '/*'); /* Process each line of the comment. */ $lines = explode($eolChar, $string); $numLines = count($lines); foreach ($lines as $lineNum => $string) { if ($lineNum !== ($numLines - 1)) { $string .= $eolChar; } $char = 0; $numChars = strlen($string); // We've started a new line, so process the indent. $space = $this->collectWhitespace($string, $char, $numChars); if ($space !== null) { $tokens[$stackPtr] = $space; $stackPtr++; if (PHP_CODESNIFFER_VERBOSITY > 1) { $content = Util\Common::prepareForOutput($space['content']); echo "\t\tCreate comment token: T_DOC_COMMENT_WHITESPACE => $content".PHP_EOL; } $char += strlen($space['content']); if ($char === $numChars) { break; } } if ($string === '') { continue; } if ($lineNum > 0 && $string[$char] === '*') { // This is a function or class doc block line. $char++; $tokens[$stackPtr] = [ 'content' => '*', 'code' => T_DOC_COMMENT_STAR, 'type' => 'T_DOC_COMMENT_STAR', ]; $stackPtr++; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\tCreate comment token: T_DOC_COMMENT_STAR => *".PHP_EOL; } } // Now we are ready to process the actual content of the line. $lineTokens = $this->processLine($string, $eolChar, $char, $numChars); foreach ($lineTokens as $lineToken) { $tokens[$stackPtr] = $lineToken; if (PHP_CODESNIFFER_VERBOSITY > 1) { $content = Util\Common::prepareForOutput($lineToken['content']); $type = $lineToken['type']; echo "\t\tCreate comment token: $type => $content".PHP_EOL; } if ($lineToken['code'] === T_DOC_COMMENT_TAG) { $tokens[$openPtr]['comment_tags'][] = $stackPtr; } $stackPtr++; } }//end foreach $tokens[$stackPtr] = $closeTag; $tokens[$openPtr]['comment_closer'] = $stackPtr; if (PHP_CODESNIFFER_VERBOSITY > 1) { $content = Util\Common::prepareForOutput($closeTag['content']); echo "\t\tCreate comment token: T_DOC_COMMENT_CLOSE_TAG => $content".PHP_EOL; } if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t*** END COMMENT TOKENIZING ***".PHP_EOL; } return $tokens; }//end tokenizeString() /** * Process a single line of a comment. * * @param string $string The comment string being tokenized. * @param string $eolChar The EOL character to use for splitting strings. * @param int $start The position in the string to start processing. * @param int $end The position in the string to end processing. * * @return array */ private function processLine($string, $eolChar, $start, $end) { $tokens = []; // Collect content padding. $space = $this->collectWhitespace($string, $start, $end); if ($space !== null) { $tokens[] = $space; $start += strlen($space['content']); } if (isset($string[$start]) === false) { return $tokens; } if ($string[$start] === '@') { // The content up until the first whitespace is the tag name. $matches = []; preg_match('/@[^\s]+/', $string, $matches, 0, $start); if (isset($matches[0]) === true && substr(strtolower($matches[0]), 0, 7) !== '@phpcs:' ) { $tagName = $matches[0]; $start += strlen($tagName); $tokens[] = [ 'content' => $tagName, 'code' => T_DOC_COMMENT_TAG, 'type' => 'T_DOC_COMMENT_TAG', ]; // Then there will be some whitespace. $space = $this->collectWhitespace($string, $start, $end); if ($space !== null) { $tokens[] = $space; $start += strlen($space['content']); } } }//end if // Process the rest of the line. $eol = strpos($string, $eolChar, $start); if ($eol === false) { $eol = $end; } if ($eol > $start) { $tokens[] = [ 'content' => substr($string, $start, ($eol - $start)), 'code' => T_DOC_COMMENT_STRING, 'type' => 'T_DOC_COMMENT_STRING', ]; } if ($eol !== $end) { $tokens[] = [ 'content' => substr($string, $eol, strlen($eolChar)), 'code' => T_DOC_COMMENT_WHITESPACE, 'type' => 'T_DOC_COMMENT_WHITESPACE', ]; } return $tokens; }//end processLine() /** * Collect consecutive whitespace into a single token. * * @param string $string The comment string being tokenized. * @param int $start The position in the string to start processing. * @param int $end The position in the string to end processing. * * @return array|null */ private function collectWhitespace($string, $start, $end) { $space = ''; for ($start; $start < $end; $start++) { if ($string[$start] !== ' ' && $string[$start] !== "\t") { break; } $space .= $string[$start]; } if ($space === '') { return null; } $token = [ 'content' => $space, 'code' => T_DOC_COMMENT_WHITESPACE, 'type' => 'T_DOC_COMMENT_WHITESPACE', ]; return $token; }//end collectWhitespace() }//end class PHP_CodeSniffer-3.5.4/src/Tokenizers/CSS.php0000644000076500000240000005327313614652362020414 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tokenizers; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Exceptions\TokenizerException; use PHP_CodeSniffer\Util; class CSS extends PHP { /** * Initialise the tokenizer. * * Pre-checks the content to see if it looks minified. * * @param string $content The content to tokenize, * @param \PHP_CodeSniffer\Config $config The config data for the run. * @param string $eolChar The EOL char used in the content. * * @return void * @throws \PHP_CodeSniffer\Exceptions\TokenizerException If the file appears to be minified. */ public function __construct($content, Config $config, $eolChar='\n') { if ($this->isMinifiedContent($content, $eolChar) === true) { throw new TokenizerException('File appears to be minified and cannot be processed'); } parent::__construct($content, $config, $eolChar); }//end __construct() /** * Creates an array of tokens when given some CSS code. * * Uses the PHP tokenizer to do all the tricky work * * @param string $string The string to tokenize. * * @return array */ public function tokenize($string) { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t*** START CSS TOKENIZING 1ST PASS ***".PHP_EOL; } // If the content doesn't have an EOL char on the end, add one so // the open and close tags we add are parsed correctly. $eolAdded = false; if (substr($string, (strlen($this->eolChar) * -1)) !== $this->eolChar) { $string .= $this->eolChar; $eolAdded = true; } $string = str_replace('', '^PHPCS_CSS_T_CLOSE_TAG^', $string); $tokens = parent::tokenize(''); $finalTokens = []; $finalTokens[0] = [ 'code' => T_OPEN_TAG, 'type' => 'T_OPEN_TAG', 'content' => '', ]; $newStackPtr = 1; $numTokens = count($tokens); $multiLineComment = false; for ($stackPtr = 1; $stackPtr < $numTokens; $stackPtr++) { $token = $tokens[$stackPtr]; // CSS files don't have lists, breaks etc, so convert these to // standard strings early so they can be converted into T_STYLE // tokens and joined with other strings if needed. if ($token['code'] === T_BREAK || $token['code'] === T_LIST || $token['code'] === T_DEFAULT || $token['code'] === T_SWITCH || $token['code'] === T_FOR || $token['code'] === T_FOREACH || $token['code'] === T_WHILE || $token['code'] === T_DEC || $token['code'] === T_NEW ) { $token['type'] = 'T_STRING'; $token['code'] = T_STRING; } $token['content'] = str_replace('^PHPCS_CSS_T_OPEN_TAG^', '', $token['content']); if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $token['type']; $content = Util\Common::prepareForOutput($token['content']); echo "\tProcess token $stackPtr: $type => $content".PHP_EOL; } if ($token['code'] === T_BITWISE_XOR && $tokens[($stackPtr + 1)]['content'] === 'PHPCS_CSS_T_OPEN_TAG' ) { $content = ''; $stackPtr += 2; break; } else { $content .= $tokens[$stackPtr]['content']; } } if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t=> Found embedded PHP code: "; $cleanContent = Util\Common::prepareForOutput($content); echo $cleanContent.PHP_EOL; } $finalTokens[$newStackPtr] = [ 'type' => 'T_EMBEDDED_PHP', 'code' => T_EMBEDDED_PHP, 'content' => $content, ]; $newStackPtr++; continue; }//end if if ($token['code'] === T_GOTO_LABEL) { // Convert these back to T_STRING followed by T_COLON so we can // more easily process style definitions. $finalTokens[$newStackPtr] = [ 'type' => 'T_STRING', 'code' => T_STRING, 'content' => substr($token['content'], 0, -1), ]; $newStackPtr++; $finalTokens[$newStackPtr] = [ 'type' => 'T_COLON', 'code' => T_COLON, 'content' => ':', ]; $newStackPtr++; continue; } if ($token['code'] === T_FUNCTION) { // There are no functions in CSS, so convert this to a string. $finalTokens[$newStackPtr] = [ 'type' => 'T_STRING', 'code' => T_STRING, 'content' => $token['content'], ]; $newStackPtr++; continue; } if ($token['code'] === T_COMMENT && substr($token['content'], 0, 2) === '/*' ) { // Multi-line comment. Record it so we can ignore other // comment tags until we get out of this one. $multiLineComment = true; } if ($token['code'] === T_COMMENT && $multiLineComment === false && (substr($token['content'], 0, 2) === '//' || $token['content'][0] === '#') ) { $content = ltrim($token['content'], '#/'); // Guard against PHP7+ syntax errors by stripping // leading zeros so the content doesn't look like an invalid int. $leadingZero = false; if ($content[0] === '0') { $content = '1'.$content; $leadingZero = true; } $commentTokens = parent::tokenize(''); // The first and last tokens are the open/close tags. array_shift($commentTokens); array_pop($commentTokens); if ($leadingZero === true) { $commentTokens[0]['content'] = substr($commentTokens[0]['content'], 1); $content = substr($content, 1); } if ($token['content'][0] === '#') { // The # character is not a comment in CSS files, so // determine what it means in this context. $firstContent = $commentTokens[0]['content']; // If the first content is just a number, it is probably a // colour like 8FB7DB, which PHP splits into 8 and FB7DB. if (($commentTokens[0]['code'] === T_LNUMBER || $commentTokens[0]['code'] === T_DNUMBER) && $commentTokens[1]['code'] === T_STRING ) { $firstContent .= $commentTokens[1]['content']; array_shift($commentTokens); } // If the first content looks like a colour and not a class // definition, join the tokens together. if (preg_match('/^[ABCDEF0-9]+$/i', $firstContent) === 1 && $commentTokens[1]['content'] !== '-' ) { array_shift($commentTokens); // Work out what we trimmed off above and remember to re-add it. $trimmed = substr($token['content'], 0, (strlen($token['content']) - strlen($content))); $finalTokens[$newStackPtr] = [ 'type' => 'T_COLOUR', 'code' => T_COLOUR, 'content' => $trimmed.$firstContent, ]; } else { $finalTokens[$newStackPtr] = [ 'type' => 'T_HASH', 'code' => T_HASH, 'content' => '#', ]; } } else { $finalTokens[$newStackPtr] = [ 'type' => 'T_STRING', 'code' => T_STRING, 'content' => '//', ]; }//end if $newStackPtr++; array_splice($tokens, $stackPtr, 1, $commentTokens); $numTokens = count($tokens); $stackPtr--; continue; }//end if if ($token['code'] === T_COMMENT && substr($token['content'], -2) === '*/' ) { // Multi-line comment is done. $multiLineComment = false; } $finalTokens[$newStackPtr] = $token; $newStackPtr++; }//end for if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t*** END CSS TOKENIZING 1ST PASS ***".PHP_EOL; echo "\t*** START CSS TOKENIZING 2ND PASS ***".PHP_EOL; } // A flag to indicate if we are inside a style definition, // which is defined using curly braces. $inStyleDef = false; // A flag to indicate if an At-rule like "@media" is used, which will result // in nested curly brackets. $asperandStart = false; $numTokens = count($finalTokens); for ($stackPtr = 0; $stackPtr < $numTokens; $stackPtr++) { $token = $finalTokens[$stackPtr]; if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $token['type']; $content = Util\Common::prepareForOutput($token['content']); echo "\tProcess token $stackPtr: $type => $content".PHP_EOL; } switch ($token['code']) { case T_OPEN_CURLY_BRACKET: // Opening curly brackets for an At-rule do not start a style // definition. We also reset the asperand flag here because the next // opening curly bracket could be indeed the start of a style // definition. if ($asperandStart === true) { if (PHP_CODESNIFFER_VERBOSITY > 1) { if ($inStyleDef === true) { echo "\t\t* style definition closed *".PHP_EOL; } if ($asperandStart === true) { echo "\t\t* at-rule definition closed *".PHP_EOL; } } $inStyleDef = false; $asperandStart = false; } else { $inStyleDef = true; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t* style definition opened *".PHP_EOL; } } break; case T_CLOSE_CURLY_BRACKET: if (PHP_CODESNIFFER_VERBOSITY > 1) { if ($inStyleDef === true) { echo "\t\t* style definition closed *".PHP_EOL; } if ($asperandStart === true) { echo "\t\t* at-rule definition closed *".PHP_EOL; } } $inStyleDef = false; $asperandStart = false; break; case T_MINUS: // Minus signs are often used instead of spaces inside // class names, IDs and styles. if ($finalTokens[($stackPtr + 1)]['code'] === T_STRING) { if ($finalTokens[($stackPtr - 1)]['code'] === T_STRING) { $newContent = $finalTokens[($stackPtr - 1)]['content'].'-'.$finalTokens[($stackPtr + 1)]['content']; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t* token is a string joiner; ignoring this and previous token".PHP_EOL; $old = Util\Common::prepareForOutput($finalTokens[($stackPtr + 1)]['content']); $new = Util\Common::prepareForOutput($newContent); echo "\t\t=> token ".($stackPtr + 1)." content changed from \"$old\" to \"$new\"".PHP_EOL; } $finalTokens[($stackPtr + 1)]['content'] = $newContent; unset($finalTokens[$stackPtr]); unset($finalTokens[($stackPtr - 1)]); } else { $newContent = '-'.$finalTokens[($stackPtr + 1)]['content']; $finalTokens[($stackPtr + 1)]['content'] = $newContent; unset($finalTokens[$stackPtr]); } } else if ($finalTokens[($stackPtr + 1)]['code'] === T_LNUMBER) { // They can also be used to provide negative numbers. if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t* token is part of a negative number; adding content to next token and ignoring *".PHP_EOL; $content = Util\Common::prepareForOutput($finalTokens[($stackPtr + 1)]['content']); echo "\t\t=> token ".($stackPtr + 1)." content changed from \"$content\" to \"-$content\"".PHP_EOL; } $finalTokens[($stackPtr + 1)]['content'] = '-'.$finalTokens[($stackPtr + 1)]['content']; unset($finalTokens[$stackPtr]); }//end if break; case T_COLON: // Only interested in colons that are defining styles. if ($inStyleDef === false) { break; } for ($x = ($stackPtr - 1); $x >= 0; $x--) { if (isset(Util\Tokens::$emptyTokens[$finalTokens[$x]['code']]) === false) { break; } } if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $finalTokens[$x]['type']; echo "\t\t=> token $x changed from $type to T_STYLE".PHP_EOL; } $finalTokens[$x]['type'] = 'T_STYLE'; $finalTokens[$x]['code'] = T_STYLE; break; case T_STRING: if (strtolower($token['content']) === 'url') { // Find the next content. for ($x = ($stackPtr + 1); $x < $numTokens; $x++) { if (isset(Util\Tokens::$emptyTokens[$finalTokens[$x]['code']]) === false) { break; } } // Needs to be in the format "url(" for it to be a URL. if ($finalTokens[$x]['code'] !== T_OPEN_PARENTHESIS) { continue 2; } // Make sure the content isn't empty. for ($y = ($x + 1); $y < $numTokens; $y++) { if (isset(Util\Tokens::$emptyTokens[$finalTokens[$y]['code']]) === false) { break; } } if ($finalTokens[$y]['code'] === T_CLOSE_PARENTHESIS) { continue 2; } if (PHP_CODESNIFFER_VERBOSITY > 1) { for ($i = ($stackPtr + 1); $i <= $y; $i++) { $type = $finalTokens[$i]['type']; $content = Util\Common::prepareForOutput($finalTokens[$i]['content']); echo "\tProcess token $i: $type => $content".PHP_EOL; } echo "\t\t* token starts a URL *".PHP_EOL; } // Join all the content together inside the url() statement. $newContent = ''; for ($i = ($x + 2); $i < $numTokens; $i++) { if ($finalTokens[$i]['code'] === T_CLOSE_PARENTHESIS) { break; } $newContent .= $finalTokens[$i]['content']; if (PHP_CODESNIFFER_VERBOSITY > 1) { $content = Util\Common::prepareForOutput($finalTokens[$i]['content']); echo "\t\t=> token $i added to URL string and ignored: $content".PHP_EOL; } unset($finalTokens[$i]); } $stackPtr = $i; // If the content inside the "url()" is in double quotes // there will only be one token and so we don't have to do // anything except change its type. If it is not empty, // we need to do some token merging. $finalTokens[($x + 1)]['type'] = 'T_URL'; $finalTokens[($x + 1)]['code'] = T_URL; if ($newContent !== '') { $finalTokens[($x + 1)]['content'] .= $newContent; if (PHP_CODESNIFFER_VERBOSITY > 1) { $content = Util\Common::prepareForOutput($finalTokens[($x + 1)]['content']); echo "\t\t=> token content changed to: $content".PHP_EOL; } } } else if ($finalTokens[$stackPtr]['content'][0] === '-' && $finalTokens[($stackPtr + 1)]['code'] === T_STRING ) { if (isset($finalTokens[($stackPtr - 1)]) === true && $finalTokens[($stackPtr - 1)]['code'] === T_STRING ) { $newContent = $finalTokens[($stackPtr - 1)]['content'].$finalTokens[$stackPtr]['content'].$finalTokens[($stackPtr + 1)]['content']; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t* token is a string joiner; ignoring this and previous token".PHP_EOL; $old = Util\Common::prepareForOutput($finalTokens[($stackPtr + 1)]['content']); $new = Util\Common::prepareForOutput($newContent); echo "\t\t=> token ".($stackPtr + 1)." content changed from \"$old\" to \"$new\"".PHP_EOL; } $finalTokens[($stackPtr + 1)]['content'] = $newContent; unset($finalTokens[$stackPtr]); unset($finalTokens[($stackPtr - 1)]); } else { $newContent = $finalTokens[$stackPtr]['content'].$finalTokens[($stackPtr + 1)]['content']; $finalTokens[($stackPtr + 1)]['content'] = $newContent; unset($finalTokens[$stackPtr]); } }//end if break; case T_ASPERAND: $asperandStart = true; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t* at-rule definition opened *".PHP_EOL; } break; default: // Nothing special to be done with this token. break; }//end switch }//end for // Reset the array keys to avoid gaps. $finalTokens = array_values($finalTokens); $numTokens = count($finalTokens); // Blank out the content of the end tag. $finalTokens[($numTokens - 1)]['content'] = ''; if ($eolAdded === true) { // Strip off the extra EOL char we added for tokenizing. $finalTokens[($numTokens - 2)]['content'] = substr( $finalTokens[($numTokens - 2)]['content'], 0, (strlen($this->eolChar) * -1) ); if ($finalTokens[($numTokens - 2)]['content'] === '') { unset($finalTokens[($numTokens - 2)]); $finalTokens = array_values($finalTokens); $numTokens = count($finalTokens); } } if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t*** END CSS TOKENIZING 2ND PASS ***".PHP_EOL; } return $finalTokens; }//end tokenize() /** * Performs additional processing after main tokenizing. * * @return void */ public function processAdditional() { /* We override this method because we don't want the PHP version to run during CSS processing because it is wasted processing time. */ }//end processAdditional() }//end class PHP_CodeSniffer-3.5.4/src/Tokenizers/JS.php0000644000076500000240000014200313614652362020266 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tokenizers; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Exceptions\TokenizerException; use PHP_CodeSniffer\Util; class JS extends Tokenizer { /** * A list of tokens that are allowed to open a scope. * * This array also contains information about what kind of token the scope * opener uses to open and close the scope, if the token strictly requires * an opener, if the token can share a scope closer, and who it can be shared * with. An example of a token that shares a scope closer is a CASE scope. * * @var array */ public $scopeOpeners = [ T_IF => [ 'start' => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET], 'end' => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET], 'strict' => false, 'shared' => false, 'with' => [], ], T_TRY => [ 'start' => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET], 'end' => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET], 'strict' => true, 'shared' => false, 'with' => [], ], T_CATCH => [ 'start' => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET], 'end' => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET], 'strict' => true, 'shared' => false, 'with' => [], ], T_ELSE => [ 'start' => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET], 'end' => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET], 'strict' => false, 'shared' => false, 'with' => [], ], T_FOR => [ 'start' => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET], 'end' => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET], 'strict' => false, 'shared' => false, 'with' => [], ], T_CLASS => [ 'start' => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET], 'end' => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET], 'strict' => true, 'shared' => false, 'with' => [], ], T_FUNCTION => [ 'start' => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET], 'end' => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET], 'strict' => false, 'shared' => false, 'with' => [], ], T_WHILE => [ 'start' => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET], 'end' => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET], 'strict' => false, 'shared' => false, 'with' => [], ], T_DO => [ 'start' => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET], 'end' => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET], 'strict' => true, 'shared' => false, 'with' => [], ], T_SWITCH => [ 'start' => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET], 'end' => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET], 'strict' => true, 'shared' => false, 'with' => [], ], T_CASE => [ 'start' => [T_COLON => T_COLON], 'end' => [ T_BREAK => T_BREAK, T_RETURN => T_RETURN, T_CONTINUE => T_CONTINUE, T_THROW => T_THROW, ], 'strict' => true, 'shared' => true, 'with' => [ T_DEFAULT => T_DEFAULT, T_CASE => T_CASE, T_SWITCH => T_SWITCH, ], ], T_DEFAULT => [ 'start' => [T_COLON => T_COLON], 'end' => [ T_BREAK => T_BREAK, T_RETURN => T_RETURN, T_CONTINUE => T_CONTINUE, T_THROW => T_THROW, ], 'strict' => true, 'shared' => true, 'with' => [ T_CASE => T_CASE, T_SWITCH => T_SWITCH, ], ], ]; /** * A list of tokens that end the scope. * * This array is just a unique collection of the end tokens * from the _scopeOpeners array. The data is duplicated here to * save time during parsing of the file. * * @var array */ public $endScopeTokens = [ T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET, T_BREAK => T_BREAK, ]; /** * A list of special JS tokens and their types. * * @var array */ protected $tokenValues = [ 'class' => 'T_CLASS', 'function' => 'T_FUNCTION', 'prototype' => 'T_PROTOTYPE', 'try' => 'T_TRY', 'catch' => 'T_CATCH', 'return' => 'T_RETURN', 'throw' => 'T_THROW', 'break' => 'T_BREAK', 'switch' => 'T_SWITCH', 'continue' => 'T_CONTINUE', 'if' => 'T_IF', 'else' => 'T_ELSE', 'do' => 'T_DO', 'while' => 'T_WHILE', 'for' => 'T_FOR', 'var' => 'T_VAR', 'case' => 'T_CASE', 'default' => 'T_DEFAULT', 'true' => 'T_TRUE', 'false' => 'T_FALSE', 'null' => 'T_NULL', 'this' => 'T_THIS', 'typeof' => 'T_TYPEOF', '(' => 'T_OPEN_PARENTHESIS', ')' => 'T_CLOSE_PARENTHESIS', '{' => 'T_OPEN_CURLY_BRACKET', '}' => 'T_CLOSE_CURLY_BRACKET', '[' => 'T_OPEN_SQUARE_BRACKET', ']' => 'T_CLOSE_SQUARE_BRACKET', '?' => 'T_INLINE_THEN', '.' => 'T_OBJECT_OPERATOR', '+' => 'T_PLUS', '-' => 'T_MINUS', '*' => 'T_MULTIPLY', '%' => 'T_MODULUS', '/' => 'T_DIVIDE', '^' => 'T_LOGICAL_XOR', ',' => 'T_COMMA', ';' => 'T_SEMICOLON', ':' => 'T_COLON', '<' => 'T_LESS_THAN', '>' => 'T_GREATER_THAN', '<<' => 'T_SL', '>>' => 'T_SR', '>>>' => 'T_ZSR', '<<=' => 'T_SL_EQUAL', '>>=' => 'T_SR_EQUAL', '>>>=' => 'T_ZSR_EQUAL', '<=' => 'T_IS_SMALLER_OR_EQUAL', '>=' => 'T_IS_GREATER_OR_EQUAL', '=>' => 'T_DOUBLE_ARROW', '!' => 'T_BOOLEAN_NOT', '||' => 'T_BOOLEAN_OR', '&&' => 'T_BOOLEAN_AND', '|' => 'T_BITWISE_OR', '&' => 'T_BITWISE_AND', '!=' => 'T_IS_NOT_EQUAL', '!==' => 'T_IS_NOT_IDENTICAL', '=' => 'T_EQUAL', '==' => 'T_IS_EQUAL', '===' => 'T_IS_IDENTICAL', '-=' => 'T_MINUS_EQUAL', '+=' => 'T_PLUS_EQUAL', '*=' => 'T_MUL_EQUAL', '/=' => 'T_DIV_EQUAL', '%=' => 'T_MOD_EQUAL', '++' => 'T_INC', '--' => 'T_DEC', '//' => 'T_COMMENT', '/*' => 'T_COMMENT', '/**' => 'T_DOC_COMMENT', '*/' => 'T_COMMENT', ]; /** * A list string delimiters. * * @var array */ protected $stringTokens = [ '\'' => '\'', '"' => '"', ]; /** * A list tokens that start and end comments. * * @var array */ protected $commentTokens = [ '//' => null, '/*' => '*/', '/**' => '*/', ]; /** * Initialise the tokenizer. * * Pre-checks the content to see if it looks minified. * * @param string $content The content to tokenize, * @param \PHP_CodeSniffer\Config $config The config data for the run. * @param string $eolChar The EOL char used in the content. * * @return void * @throws \PHP_CodeSniffer\Exceptions\TokenizerException If the file appears to be minified. */ public function __construct($content, Config $config, $eolChar='\n') { if ($this->isMinifiedContent($content, $eolChar) === true) { throw new TokenizerException('File appears to be minified and cannot be processed'); } parent::__construct($content, $config, $eolChar); }//end __construct() /** * Creates an array of tokens when given some JS code. * * @param string $string The string to tokenize. * * @return array */ public function tokenize($string) { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t*** START JS TOKENIZING ***".PHP_EOL; } $maxTokenLength = 0; foreach ($this->tokenValues as $token => $values) { if (strlen($token) > $maxTokenLength) { $maxTokenLength = strlen($token); } } $tokens = []; $inString = ''; $stringChar = null; $inComment = ''; $buffer = ''; $preStringBuffer = ''; $cleanBuffer = false; $commentTokenizer = new Comment(); $tokens[] = [ 'code' => T_OPEN_TAG, 'type' => 'T_OPEN_TAG', 'content' => '', ]; // Convert newlines to single characters for ease of // processing. We will change them back later. $string = str_replace($this->eolChar, "\n", $string); $chars = str_split($string); $numChars = count($chars); for ($i = 0; $i < $numChars; $i++) { $char = $chars[$i]; if (PHP_CODESNIFFER_VERBOSITY > 1) { $content = Util\Common::prepareForOutput($char); $bufferContent = Util\Common::prepareForOutput($buffer); if ($inString !== '') { echo "\t"; } if ($inComment !== '') { echo "\t"; } echo "\tProcess char $i => $content (buffer: $bufferContent)".PHP_EOL; }//end if if ($inString === '' && $inComment === '' && $buffer !== '') { // If the buffer only has whitespace and we are about to // add a character, store the whitespace first. if (trim($char) !== '' && trim($buffer) === '') { $tokens[] = [ 'code' => T_WHITESPACE, 'type' => 'T_WHITESPACE', 'content' => str_replace("\n", $this->eolChar, $buffer), ]; if (PHP_CODESNIFFER_VERBOSITY > 1) { $content = Util\Common::prepareForOutput($buffer); echo "\t=> Added token T_WHITESPACE ($content)".PHP_EOL; } $buffer = ''; } // If the buffer is not whitespace and we are about to // add a whitespace character, store the content first. if ($inString === '' && $inComment === '' && trim($char) === '' && trim($buffer) !== '' ) { $tokens[] = [ 'code' => T_STRING, 'type' => 'T_STRING', 'content' => str_replace("\n", $this->eolChar, $buffer), ]; if (PHP_CODESNIFFER_VERBOSITY > 1) { $content = Util\Common::prepareForOutput($buffer); echo "\t=> Added token T_STRING ($content)".PHP_EOL; } $buffer = ''; } }//end if // Process strings. if ($inComment === '' && isset($this->stringTokens[$char]) === true) { if ($inString === $char) { // This could be the end of the string, but make sure it // is not escaped first. $escapes = 0; for ($x = ($i - 1); $x >= 0; $x--) { if ($chars[$x] !== '\\') { break; } $escapes++; } if ($escapes === 0 || ($escapes % 2) === 0) { // There is an even number escape chars, // so this is not escaped, it is the end of the string. $tokens[] = [ 'code' => T_CONSTANT_ENCAPSED_STRING, 'type' => 'T_CONSTANT_ENCAPSED_STRING', 'content' => str_replace("\n", $this->eolChar, $buffer).$char, ]; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t* found end of string *".PHP_EOL; $content = Util\Common::prepareForOutput($buffer.$char); echo "\t=> Added token T_CONSTANT_ENCAPSED_STRING ($content)".PHP_EOL; } $buffer = ''; $preStringBuffer = ''; $inString = ''; $stringChar = null; continue; }//end if } else if ($inString === '') { $inString = $char; $stringChar = $i; $preStringBuffer = $buffer; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t* looking for string closer *".PHP_EOL; } }//end if }//end if if ($inString !== '' && $char === "\n") { // Unless this newline character is escaped, the string did not // end before the end of the line, which means it probably // wasn't a string at all (maybe a regex). if ($chars[($i - 1)] !== '\\') { $i = $stringChar; $buffer = $preStringBuffer; $preStringBuffer = ''; $inString = ''; $stringChar = null; $char = $chars[$i]; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t* found newline before end of string, bailing *".PHP_EOL; } } } $buffer .= $char; // We don't look for special tokens inside strings, // so if we are in a string, we can continue here now // that the current char is in the buffer. if ($inString !== '') { continue; } // Special case for T_DIVIDE which can actually be // the start of a regular expression. if ($buffer === $char && $char === '/' && $chars[($i + 1)] !== '*') { $regex = $this->getRegexToken($i, $string, $chars, $tokens); if ($regex !== null) { $tokens[] = [ 'code' => T_REGULAR_EXPRESSION, 'type' => 'T_REGULAR_EXPRESSION', 'content' => $regex['content'], ]; if (PHP_CODESNIFFER_VERBOSITY > 1) { $content = Util\Common::prepareForOutput($regex['content']); echo "\t=> Added token T_REGULAR_EXPRESSION ($content)".PHP_EOL; } $i = $regex['end']; $buffer = ''; $cleanBuffer = false; continue; }//end if }//end if // Check for known tokens, but ignore tokens found that are not at // the end of a string, like FOR and this.FORmat. if (isset($this->tokenValues[strtolower($buffer)]) === true && (preg_match('|[a-zA-z0-9_]|', $char) === 0 || isset($chars[($i + 1)]) === false || preg_match('|[a-zA-z0-9_]|', $chars[($i + 1)]) === 0) ) { $matchedToken = false; $lookAheadLength = ($maxTokenLength - strlen($buffer)); if ($lookAheadLength > 0) { // The buffer contains a token type, but we need // to look ahead at the next chars to see if this is // actually part of a larger token. For example, // FOR and FOREACH. if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t* buffer possibly contains token, looking ahead $lookAheadLength chars *".PHP_EOL; } $charBuffer = $buffer; for ($x = 1; $x <= $lookAheadLength; $x++) { if (isset($chars[($i + $x)]) === false) { break; } $charBuffer .= $chars[($i + $x)]; if (PHP_CODESNIFFER_VERBOSITY > 1) { $content = Util\Common::prepareForOutput($charBuffer); echo "\t\t=> Looking ahead $x chars => $content".PHP_EOL; } if (isset($this->tokenValues[strtolower($charBuffer)]) === true) { // We've found something larger that matches // so we can ignore this char. Except for 1 very specific // case where a comment like /**/ needs to tokenize as // T_COMMENT and not T_DOC_COMMENT. $oldType = $this->tokenValues[strtolower($buffer)]; $newType = $this->tokenValues[strtolower($charBuffer)]; if ($oldType === 'T_COMMENT' && $newType === 'T_DOC_COMMENT' && $chars[($i + $x + 1)] === '/' ) { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t* look ahead ignored T_DOC_COMMENT, continuing *".PHP_EOL; } } else { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t* look ahead found more specific token ($newType), ignoring $i *".PHP_EOL; } $matchedToken = true; break; } }//end if }//end for }//end if if ($matchedToken === false) { if (PHP_CODESNIFFER_VERBOSITY > 1 && $lookAheadLength > 0) { echo "\t\t* look ahead found nothing *".PHP_EOL; } $value = $this->tokenValues[strtolower($buffer)]; if ($value === 'T_FUNCTION' && $buffer !== 'function') { // The function keyword needs to be all lowercase or else // it is just a function called "Function". $value = 'T_STRING'; } $tokens[] = [ 'code' => constant($value), 'type' => $value, 'content' => $buffer, ]; if (PHP_CODESNIFFER_VERBOSITY > 1) { $content = Util\Common::prepareForOutput($buffer); echo "\t=> Added token $value ($content)".PHP_EOL; } $cleanBuffer = true; }//end if } else if (isset($this->tokenValues[strtolower($char)]) === true) { // No matter what token we end up using, we don't // need the content in the buffer any more because we have // found a valid token. $newContent = substr(str_replace("\n", $this->eolChar, $buffer), 0, -1); if ($newContent !== '') { $tokens[] = [ 'code' => T_STRING, 'type' => 'T_STRING', 'content' => $newContent, ]; if (PHP_CODESNIFFER_VERBOSITY > 1) { $content = Util\Common::prepareForOutput(substr($buffer, 0, -1)); echo "\t=> Added token T_STRING ($content)".PHP_EOL; } } if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t* char is token, looking ahead ".($maxTokenLength - 1).' chars *'.PHP_EOL; } // The char is a token type, but we need to look ahead at the // next chars to see if this is actually part of a larger token. // For example, = and ===. $charBuffer = $char; $matchedToken = false; for ($x = 1; $x <= $maxTokenLength; $x++) { if (isset($chars[($i + $x)]) === false) { break; } $charBuffer .= $chars[($i + $x)]; if (PHP_CODESNIFFER_VERBOSITY > 1) { $content = Util\Common::prepareForOutput($charBuffer); echo "\t\t=> Looking ahead $x chars => $content".PHP_EOL; } if (isset($this->tokenValues[strtolower($charBuffer)]) === true) { // We've found something larger that matches // so we can ignore this char. if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokenValues[strtolower($charBuffer)]; echo "\t\t* look ahead found more specific token ($type), ignoring $i *".PHP_EOL; } $matchedToken = true; break; } }//end for if ($matchedToken === false) { $value = $this->tokenValues[strtolower($char)]; $tokens[] = [ 'code' => constant($value), 'type' => $value, 'content' => $char, ]; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t* look ahead found nothing *".PHP_EOL; $content = Util\Common::prepareForOutput($char); echo "\t=> Added token $value ($content)".PHP_EOL; } $cleanBuffer = true; } else { $buffer = $char; }//end if }//end if // Keep track of content inside comments. if ($inComment === '' && array_key_exists($buffer, $this->commentTokens) === true ) { // This is not really a comment if the content // looks like \// (i.e., it is escaped). if (isset($chars[($i - 2)]) === true && $chars[($i - 2)] === '\\') { $lastToken = array_pop($tokens); $lastContent = $lastToken['content']; if (PHP_CODESNIFFER_VERBOSITY > 1) { $value = $this->tokenValues[strtolower($lastContent)]; $content = Util\Common::prepareForOutput($lastContent); echo "\t=> Removed token $value ($content)".PHP_EOL; } $lastChars = str_split($lastContent); $lastNumChars = count($lastChars); for ($x = 0; $x < $lastNumChars; $x++) { $lastChar = $lastChars[$x]; $value = $this->tokenValues[strtolower($lastChar)]; $tokens[] = [ 'code' => constant($value), 'type' => $value, 'content' => $lastChar, ]; if (PHP_CODESNIFFER_VERBOSITY > 1) { $content = Util\Common::prepareForOutput($lastChar); echo "\t=> Added token $value ($content)".PHP_EOL; } } } else { // We have started a comment. $inComment = $buffer; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t* looking for end of comment *".PHP_EOL; } }//end if } else if ($inComment !== '') { if ($this->commentTokens[$inComment] === null) { // Comment ends at the next newline. if (strpos($buffer, "\n") !== false) { $inComment = ''; } } else { if ($this->commentTokens[$inComment] === $buffer) { $inComment = ''; } } if (PHP_CODESNIFFER_VERBOSITY > 1) { if ($inComment === '') { echo "\t\t* found end of comment *".PHP_EOL; } } if ($inComment === '' && $cleanBuffer === false) { $tokens[] = [ 'code' => T_STRING, 'type' => 'T_STRING', 'content' => str_replace("\n", $this->eolChar, $buffer), ]; if (PHP_CODESNIFFER_VERBOSITY > 1) { $content = Util\Common::prepareForOutput($buffer); echo "\t=> Added token T_STRING ($content)".PHP_EOL; } $buffer = ''; } }//end if if ($cleanBuffer === true) { $buffer = ''; $cleanBuffer = false; } }//end for if (empty($buffer) === false) { if ($inString !== '') { // The string did not end before the end of the file, // which means there was probably a syntax error somewhere. $tokens[] = [ 'code' => T_STRING, 'type' => 'T_STRING', 'content' => str_replace("\n", $this->eolChar, $buffer), ]; if (PHP_CODESNIFFER_VERBOSITY > 1) { $content = Util\Common::prepareForOutput($buffer); echo "\t=> Added token T_STRING ($content)".PHP_EOL; } } else { // Buffer contains whitespace from the end of the file. $tokens[] = [ 'code' => T_WHITESPACE, 'type' => 'T_WHITESPACE', 'content' => str_replace("\n", $this->eolChar, $buffer), ]; if (PHP_CODESNIFFER_VERBOSITY > 1) { $content = Util\Common::prepareForOutput($buffer); echo "\t=> Added token T_WHITESPACE ($content)".PHP_EOL; } }//end if }//end if $tokens[] = [ 'code' => T_CLOSE_TAG, 'type' => 'T_CLOSE_TAG', 'content' => '', ]; /* Now that we have done some basic tokenizing, we need to modify the tokens to join some together and split some apart so they match what the PHP tokenizer does. */ $finalTokens = []; $newStackPtr = 0; $numTokens = count($tokens); for ($stackPtr = 0; $stackPtr < $numTokens; $stackPtr++) { $token = $tokens[$stackPtr]; /* Look for comments and join the tokens together. */ if ($token['code'] === T_COMMENT || $token['code'] === T_DOC_COMMENT) { $newContent = ''; $tokenContent = $token['content']; $endContent = null; if (isset($this->commentTokens[$tokenContent]) === true) { $endContent = $this->commentTokens[$tokenContent]; } while ($tokenContent !== $endContent) { if ($endContent === null && strpos($tokenContent, $this->eolChar) !== false ) { // A null end token means the comment ends at the end of // the line so we look for newlines and split the token. $tokens[$stackPtr]['content'] = substr( $tokenContent, (strpos($tokenContent, $this->eolChar) + strlen($this->eolChar)) ); $tokenContent = substr( $tokenContent, 0, (strpos($tokenContent, $this->eolChar) + strlen($this->eolChar)) ); // If the substr failed, skip the token as the content // will now be blank. if ($tokens[$stackPtr]['content'] !== false && $tokens[$stackPtr]['content'] !== '' ) { $stackPtr--; } break; }//end if $stackPtr++; $newContent .= $tokenContent; if (isset($tokens[$stackPtr]) === false) { break; } $tokenContent = $tokens[$stackPtr]['content']; }//end while if ($token['code'] === T_DOC_COMMENT) { $commentTokens = $commentTokenizer->tokenizeString($newContent.$tokenContent, $this->eolChar, $newStackPtr); foreach ($commentTokens as $commentToken) { $finalTokens[$newStackPtr] = $commentToken; $newStackPtr++; } continue; } else { // Save the new content in the current token so // the code below can chop it up on newlines. $token['content'] = $newContent.$tokenContent; } }//end if /* If this token has newlines in its content, split each line up and create a new token for each line. We do this so it's easier to ascertain where errors occur on a line. Note that $token[1] is the token's content. */ if (strpos($token['content'], $this->eolChar) !== false) { $tokenLines = explode($this->eolChar, $token['content']); $numLines = count($tokenLines); for ($i = 0; $i < $numLines; $i++) { $newToken = ['content' => $tokenLines[$i]]; if ($i === ($numLines - 1)) { if ($tokenLines[$i] === '') { break; } } else { $newToken['content'] .= $this->eolChar; } $newToken['type'] = $token['type']; $newToken['code'] = $token['code']; $finalTokens[$newStackPtr] = $newToken; $newStackPtr++; } } else { $finalTokens[$newStackPtr] = $token; $newStackPtr++; }//end if // Convert numbers, including decimals. if ($token['code'] === T_STRING || $token['code'] === T_OBJECT_OPERATOR ) { $newContent = ''; $oldStackPtr = $stackPtr; while (preg_match('|^[0-9\.]+$|', $tokens[$stackPtr]['content']) !== 0) { $newContent .= $tokens[$stackPtr]['content']; $stackPtr++; } if ($newContent !== '' && $newContent !== '.') { $finalTokens[($newStackPtr - 1)]['content'] = $newContent; if (ctype_digit($newContent) === true) { $finalTokens[($newStackPtr - 1)]['code'] = constant('T_LNUMBER'); $finalTokens[($newStackPtr - 1)]['type'] = 'T_LNUMBER'; } else { $finalTokens[($newStackPtr - 1)]['code'] = constant('T_DNUMBER'); $finalTokens[($newStackPtr - 1)]['type'] = 'T_DNUMBER'; } $stackPtr--; continue; } else { $stackPtr = $oldStackPtr; } }//end if // Convert the token after an object operator into a string, in most cases. if ($token['code'] === T_OBJECT_OPERATOR) { for ($i = ($stackPtr + 1); $i < $numTokens; $i++) { if (isset(Util\Tokens::$emptyTokens[$tokens[$i]['code']]) === true) { continue; } if ($tokens[$i]['code'] !== T_PROTOTYPE && $tokens[$i]['code'] !== T_LNUMBER && $tokens[$i]['code'] !== T_DNUMBER ) { $tokens[$i]['code'] = T_STRING; $tokens[$i]['type'] = 'T_STRING'; } break; } } }//end for if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t*** END TOKENIZING ***".PHP_EOL; } return $finalTokens; }//end tokenize() /** * Tokenizes a regular expression if one is found. * * If a regular expression is not found, NULL is returned. * * @param string $char The index of the possible regex start character. * @param string $string The complete content of the string being tokenized. * @param string $chars An array of characters being tokenized. * @param string $tokens The current array of tokens found in the string. * * @return array|null */ public function getRegexToken($char, $string, $chars, $tokens) { $beforeTokens = [ T_EQUAL => true, T_IS_NOT_EQUAL => true, T_IS_IDENTICAL => true, T_IS_NOT_IDENTICAL => true, T_OPEN_PARENTHESIS => true, T_OPEN_SQUARE_BRACKET => true, T_RETURN => true, T_BOOLEAN_OR => true, T_BOOLEAN_AND => true, T_BOOLEAN_NOT => true, T_BITWISE_OR => true, T_BITWISE_AND => true, T_COMMA => true, T_COLON => true, T_TYPEOF => true, T_INLINE_THEN => true, T_INLINE_ELSE => true, ]; $afterTokens = [ ',' => true, ')' => true, ']' => true, ';' => true, ' ' => true, '.' => true, ':' => true, $this->eolChar => true, ]; // Find the last non-whitespace token that was added // to the tokens array. $numTokens = count($tokens); for ($prev = ($numTokens - 1); $prev >= 0; $prev--) { if (isset(Util\Tokens::$emptyTokens[$tokens[$prev]['code']]) === false) { break; } } if (isset($beforeTokens[$tokens[$prev]['code']]) === false) { return null; } // This is probably a regular expression, so look for the end of it. if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t* token possibly starts a regular expression *".PHP_EOL; } $numChars = count($chars); for ($next = ($char + 1); $next < $numChars; $next++) { if ($chars[$next] === '/') { // Just make sure this is not escaped first. if ($chars[($next - 1)] !== '\\') { // In the simple form: /.../ so we found the end. break; } else if ($chars[($next - 2)] === '\\') { // In the form: /...\\/ so we found the end. break; } } else { $possibleEolChar = substr($string, $next, strlen($this->eolChar)); if ($possibleEolChar === $this->eolChar) { // This is the last token on the line and regular // expressions need to be defined on a single line, // so this is not a regular expression. break; } } } if ($chars[$next] !== '/') { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t* could not find end of regular expression *".PHP_EOL; } return null; } while (preg_match('|[a-zA-Z]|', $chars[($next + 1)]) !== 0) { // The token directly after the end of the regex can // be modifiers like global and case insensitive // (.e.g, /pattern/gi). $next++; } $regexEnd = $next; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t* found end of regular expression at token $regexEnd *".PHP_EOL; } for ($next += 1; $next < $numChars; $next++) { if ($chars[$next] !== ' ') { break; } else { $possibleEolChar = substr($string, $next, strlen($this->eolChar)); if ($possibleEolChar === $this->eolChar) { // This is the last token on the line. break; } } } if (isset($afterTokens[$chars[$next]]) === false) { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t* tokens after regular expression do not look correct *".PHP_EOL; } return null; } // This is a regular expression, so join all the tokens together. $content = ''; for ($x = $char; $x <= $regexEnd; $x++) { $content .= $chars[$x]; } $token = [ 'start' => $char, 'end' => $regexEnd, 'content' => $content, ]; return $token; }//end getRegexToken() /** * Performs additional processing after main tokenizing. * * This additional processing looks for properties, closures, labels and objects. * * @return void */ public function processAdditional() { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t*** START ADDITIONAL JS PROCESSING ***".PHP_EOL; } $numTokens = count($this->tokens); $classStack = []; for ($i = 0; $i < $numTokens; $i++) { if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$i]['type']; $content = Util\Common::prepareForOutput($this->tokens[$i]['content']); echo str_repeat("\t", count($classStack)); echo "\tProcess token $i: $type => $content".PHP_EOL; } // Looking for functions that are actually closures. if ($this->tokens[$i]['code'] === T_FUNCTION && isset($this->tokens[$i]['scope_opener']) === true) { for ($x = ($i + 1); $x < $numTokens; $x++) { if (isset(Util\Tokens::$emptyTokens[$this->tokens[$x]['code']]) === false) { break; } } if ($this->tokens[$x]['code'] === T_OPEN_PARENTHESIS) { $this->tokens[$i]['code'] = T_CLOSURE; $this->tokens[$i]['type'] = 'T_CLOSURE'; if (PHP_CODESNIFFER_VERBOSITY > 1) { $line = $this->tokens[$i]['line']; echo str_repeat("\t", count($classStack)); echo "\t* token $i on line $line changed from T_FUNCTION to T_CLOSURE *".PHP_EOL; } for ($x = ($this->tokens[$i]['scope_opener'] + 1); $x < $this->tokens[$i]['scope_closer']; $x++) { if (isset($this->tokens[$x]['conditions'][$i]) === false) { continue; } $this->tokens[$x]['conditions'][$i] = T_CLOSURE; if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$x]['type']; echo str_repeat("\t", count($classStack)); echo "\t\t* cleaned $x ($type) *".PHP_EOL; } } }//end if continue; } else if ($this->tokens[$i]['code'] === T_OPEN_CURLY_BRACKET && isset($this->tokens[$i]['scope_condition']) === false && isset($this->tokens[$i]['bracket_closer']) === true ) { $condition = $this->tokens[$i]['conditions']; $condition = end($condition); if ($condition === T_CLASS) { // Possibly an ES6 method. To be classified as one, the previous // non-empty tokens need to be a set of parenthesis, and then a string // (the method name). for ($parenCloser = ($i - 1); $parenCloser > 0; $parenCloser--) { if (isset(Util\Tokens::$emptyTokens[$this->tokens[$parenCloser]['code']]) === false) { break; } } if ($this->tokens[$parenCloser]['code'] === T_CLOSE_PARENTHESIS) { $parenOpener = $this->tokens[$parenCloser]['parenthesis_opener']; for ($name = ($parenOpener - 1); $name > 0; $name--) { if (isset(Util\Tokens::$emptyTokens[$this->tokens[$name]['code']]) === false) { break; } } if ($this->tokens[$name]['code'] === T_STRING) { // We found a method name. if (PHP_CODESNIFFER_VERBOSITY > 1) { $line = $this->tokens[$name]['line']; echo str_repeat("\t", count($classStack)); echo "\t* token $name on line $line changed from T_STRING to T_FUNCTION *".PHP_EOL; } $closer = $this->tokens[$i]['bracket_closer']; $this->tokens[$name]['code'] = T_FUNCTION; $this->tokens[$name]['type'] = 'T_FUNCTION'; foreach ([$name, $i, $closer] as $token) { $this->tokens[$token]['scope_condition'] = $name; $this->tokens[$token]['scope_opener'] = $i; $this->tokens[$token]['scope_closer'] = $closer; $this->tokens[$token]['parenthesis_opener'] = $parenOpener; $this->tokens[$token]['parenthesis_closer'] = $parenCloser; $this->tokens[$token]['parenthesis_owner'] = $name; } $this->tokens[$parenOpener]['parenthesis_owner'] = $name; $this->tokens[$parenCloser]['parenthesis_owner'] = $name; for ($x = ($i + 1); $x < $closer; $x++) { $this->tokens[$x]['conditions'][$name] = T_FUNCTION; ksort($this->tokens[$x]['conditions'], SORT_NUMERIC); if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$x]['type']; echo str_repeat("\t", count($classStack)); echo "\t\t* added T_FUNCTION condition to $x ($type) *".PHP_EOL; } } continue; }//end if }//end if }//end if $classStack[] = $i; $closer = $this->tokens[$i]['bracket_closer']; $this->tokens[$i]['code'] = T_OBJECT; $this->tokens[$i]['type'] = 'T_OBJECT'; $this->tokens[$closer]['code'] = T_CLOSE_OBJECT; $this->tokens[$closer]['type'] = 'T_CLOSE_OBJECT'; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", count($classStack)); echo "\t* token $i converted from T_OPEN_CURLY_BRACKET to T_OBJECT *".PHP_EOL; echo str_repeat("\t", count($classStack)); echo "\t* token $closer converted from T_CLOSE_CURLY_BRACKET to T_CLOSE_OBJECT *".PHP_EOL; } for ($x = ($i + 1); $x < $closer; $x++) { $this->tokens[$x]['conditions'][$i] = T_OBJECT; ksort($this->tokens[$x]['conditions'], SORT_NUMERIC); if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$x]['type']; echo str_repeat("\t", count($classStack)); echo "\t\t* added T_OBJECT condition to $x ($type) *".PHP_EOL; } } } else if ($this->tokens[$i]['code'] === T_CLOSE_OBJECT) { $opener = array_pop($classStack); } else if ($this->tokens[$i]['code'] === T_COLON) { // If it is a scope opener, it belongs to a // DEFAULT or CASE statement. if (isset($this->tokens[$i]['scope_condition']) === true) { continue; } // Make sure this is not part of an inline IF statement. for ($x = ($i - 1); $x >= 0; $x--) { if ($this->tokens[$x]['code'] === T_INLINE_THEN) { $this->tokens[$i]['code'] = T_INLINE_ELSE; $this->tokens[$i]['type'] = 'T_INLINE_ELSE'; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", count($classStack)); echo "\t* token $i converted from T_COLON to T_INLINE_THEN *".PHP_EOL; } continue(2); } else if ($this->tokens[$x]['line'] < $this->tokens[$i]['line']) { break; } } // The string to the left of the colon is either a property or label. for ($label = ($i - 1); $label >= 0; $label--) { if (isset(Util\Tokens::$emptyTokens[$this->tokens[$label]['code']]) === false) { break; } } if ($this->tokens[$label]['code'] !== T_STRING && $this->tokens[$label]['code'] !== T_CONSTANT_ENCAPSED_STRING ) { continue; } if (empty($classStack) === false) { $this->tokens[$label]['code'] = T_PROPERTY; $this->tokens[$label]['type'] = 'T_PROPERTY'; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", count($classStack)); echo "\t* token $label converted from T_STRING to T_PROPERTY *".PHP_EOL; } } else { $this->tokens[$label]['code'] = T_LABEL; $this->tokens[$label]['type'] = 'T_LABEL'; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", count($classStack)); echo "\t* token $label converted from T_STRING to T_LABEL *".PHP_EOL; } }//end if }//end if }//end for if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t*** END ADDITIONAL JS PROCESSING ***".PHP_EOL; } }//end processAdditional() }//end class PHP_CodeSniffer-3.5.4/src/Tokenizers/PHP.php0000644000076500000240000027625513614652362020422 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tokenizers; use PHP_CodeSniffer\Util; class PHP extends Tokenizer { /** * A list of tokens that are allowed to open a scope. * * This array also contains information about what kind of token the scope * opener uses to open and close the scope, if the token strictly requires * an opener, if the token can share a scope closer, and who it can be shared * with. An example of a token that shares a scope closer is a CASE scope. * * @var array */ public $scopeOpeners = [ T_IF => [ 'start' => [ T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET, T_COLON => T_COLON, ], 'end' => [ T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET, T_ENDIF => T_ENDIF, T_ELSE => T_ELSE, T_ELSEIF => T_ELSEIF, ], 'strict' => false, 'shared' => false, 'with' => [ T_ELSE => T_ELSE, T_ELSEIF => T_ELSEIF, ], ], T_TRY => [ 'start' => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET], 'end' => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET], 'strict' => true, 'shared' => false, 'with' => [], ], T_CATCH => [ 'start' => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET], 'end' => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET], 'strict' => true, 'shared' => false, 'with' => [], ], T_FINALLY => [ 'start' => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET], 'end' => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET], 'strict' => true, 'shared' => false, 'with' => [], ], T_ELSE => [ 'start' => [ T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET, T_COLON => T_COLON, ], 'end' => [ T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET, T_ENDIF => T_ENDIF, ], 'strict' => false, 'shared' => false, 'with' => [ T_IF => T_IF, T_ELSEIF => T_ELSEIF, ], ], T_ELSEIF => [ 'start' => [ T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET, T_COLON => T_COLON, ], 'end' => [ T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET, T_ENDIF => T_ENDIF, T_ELSE => T_ELSE, T_ELSEIF => T_ELSEIF, ], 'strict' => false, 'shared' => false, 'with' => [ T_IF => T_IF, T_ELSE => T_ELSE, ], ], T_FOR => [ 'start' => [ T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET, T_COLON => T_COLON, ], 'end' => [ T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET, T_ENDFOR => T_ENDFOR, ], 'strict' => false, 'shared' => false, 'with' => [], ], T_FOREACH => [ 'start' => [ T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET, T_COLON => T_COLON, ], 'end' => [ T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET, T_ENDFOREACH => T_ENDFOREACH, ], 'strict' => false, 'shared' => false, 'with' => [], ], T_INTERFACE => [ 'start' => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET], 'end' => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET], 'strict' => true, 'shared' => false, 'with' => [], ], T_FUNCTION => [ 'start' => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET], 'end' => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET], 'strict' => true, 'shared' => false, 'with' => [], ], T_CLASS => [ 'start' => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET], 'end' => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET], 'strict' => true, 'shared' => false, 'with' => [], ], T_TRAIT => [ 'start' => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET], 'end' => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET], 'strict' => true, 'shared' => false, 'with' => [], ], T_USE => [ 'start' => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET], 'end' => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET], 'strict' => false, 'shared' => false, 'with' => [], ], T_DECLARE => [ 'start' => [ T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET, T_COLON => T_COLON, ], 'end' => [ T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET, T_ENDDECLARE => T_ENDDECLARE, ], 'strict' => false, 'shared' => false, 'with' => [], ], T_NAMESPACE => [ 'start' => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET], 'end' => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET], 'strict' => false, 'shared' => false, 'with' => [], ], T_WHILE => [ 'start' => [ T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET, T_COLON => T_COLON, ], 'end' => [ T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET, T_ENDWHILE => T_ENDWHILE, ], 'strict' => false, 'shared' => false, 'with' => [], ], T_DO => [ 'start' => [T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET], 'end' => [T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET], 'strict' => true, 'shared' => false, 'with' => [], ], T_SWITCH => [ 'start' => [ T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET, T_COLON => T_COLON, ], 'end' => [ T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET, T_ENDSWITCH => T_ENDSWITCH, ], 'strict' => true, 'shared' => false, 'with' => [], ], T_CASE => [ 'start' => [ T_COLON => T_COLON, T_SEMICOLON => T_SEMICOLON, ], 'end' => [ T_BREAK => T_BREAK, T_RETURN => T_RETURN, T_CONTINUE => T_CONTINUE, T_THROW => T_THROW, T_EXIT => T_EXIT, ], 'strict' => true, 'shared' => true, 'with' => [ T_DEFAULT => T_DEFAULT, T_CASE => T_CASE, T_SWITCH => T_SWITCH, ], ], T_DEFAULT => [ 'start' => [ T_COLON => T_COLON, T_SEMICOLON => T_SEMICOLON, ], 'end' => [ T_BREAK => T_BREAK, T_RETURN => T_RETURN, T_CONTINUE => T_CONTINUE, T_THROW => T_THROW, T_EXIT => T_EXIT, ], 'strict' => true, 'shared' => true, 'with' => [ T_CASE => T_CASE, T_SWITCH => T_SWITCH, ], ], T_START_HEREDOC => [ 'start' => [T_START_HEREDOC => T_START_HEREDOC], 'end' => [T_END_HEREDOC => T_END_HEREDOC], 'strict' => true, 'shared' => false, 'with' => [], ], T_START_NOWDOC => [ 'start' => [T_START_NOWDOC => T_START_NOWDOC], 'end' => [T_END_NOWDOC => T_END_NOWDOC], 'strict' => true, 'shared' => false, 'with' => [], ], ]; /** * A list of tokens that end the scope. * * This array is just a unique collection of the end tokens * from the scopeOpeners array. The data is duplicated here to * save time during parsing of the file. * * @var array */ public $endScopeTokens = [ T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET, T_ENDIF => T_ENDIF, T_ENDFOR => T_ENDFOR, T_ENDFOREACH => T_ENDFOREACH, T_ENDWHILE => T_ENDWHILE, T_ENDSWITCH => T_ENDSWITCH, T_BREAK => T_BREAK, T_END_HEREDOC => T_END_HEREDOC, ]; /** * Known lengths of tokens. * * @var array */ public $knownLengths = [ T_ABSTRACT => 8, T_AND_EQUAL => 2, T_ARRAY => 5, T_AS => 2, T_BOOLEAN_AND => 2, T_BOOLEAN_OR => 2, T_BREAK => 5, T_CALLABLE => 8, T_CASE => 4, T_CATCH => 5, T_CLASS => 5, T_CLASS_C => 9, T_CLONE => 5, T_CONCAT_EQUAL => 2, T_CONST => 5, T_CONTINUE => 8, T_CURLY_OPEN => 2, T_DEC => 2, T_DECLARE => 7, T_DEFAULT => 7, T_DIR => 7, T_DIV_EQUAL => 2, T_DO => 2, T_DOLLAR_OPEN_CURLY_BRACES => 2, T_DOUBLE_ARROW => 2, T_DOUBLE_COLON => 2, T_ECHO => 4, T_ELSE => 4, T_ELSEIF => 6, T_EMPTY => 5, T_ENDDECLARE => 10, T_ENDFOR => 6, T_ENDFOREACH => 10, T_ENDIF => 5, T_ENDSWITCH => 9, T_ENDWHILE => 8, T_EVAL => 4, T_EXTENDS => 7, T_FILE => 8, T_FINAL => 5, T_FINALLY => 7, T_FOR => 3, T_FOREACH => 7, T_FUNCTION => 8, T_FUNC_C => 12, T_GLOBAL => 6, T_GOTO => 4, T_HALT_COMPILER => 15, T_IF => 2, T_IMPLEMENTS => 10, T_INC => 2, T_INCLUDE => 7, T_INCLUDE_ONCE => 12, T_INSTANCEOF => 10, T_INSTEADOF => 9, T_INTERFACE => 9, T_ISSET => 5, T_IS_EQUAL => 2, T_IS_GREATER_OR_EQUAL => 2, T_IS_IDENTICAL => 3, T_IS_NOT_EQUAL => 2, T_IS_NOT_IDENTICAL => 3, T_IS_SMALLER_OR_EQUAL => 2, T_LINE => 8, T_LIST => 4, T_LOGICAL_AND => 3, T_LOGICAL_OR => 2, T_LOGICAL_XOR => 3, T_METHOD_C => 10, T_MINUS_EQUAL => 2, T_POW_EQUAL => 3, T_MOD_EQUAL => 2, T_MUL_EQUAL => 2, T_NAMESPACE => 9, T_NS_C => 13, T_NS_SEPARATOR => 1, T_NEW => 3, T_OBJECT_OPERATOR => 2, T_OPEN_TAG_WITH_ECHO => 3, T_OR_EQUAL => 2, T_PLUS_EQUAL => 2, T_PRINT => 5, T_PRIVATE => 7, T_PUBLIC => 6, T_PROTECTED => 9, T_REQUIRE => 7, T_REQUIRE_ONCE => 12, T_RETURN => 6, T_STATIC => 6, T_SWITCH => 6, T_THROW => 5, T_TRAIT => 5, T_TRAIT_C => 9, T_TRY => 3, T_UNSET => 5, T_USE => 3, T_VAR => 3, T_WHILE => 5, T_XOR_EQUAL => 2, T_YIELD => 5, T_OPEN_CURLY_BRACKET => 1, T_CLOSE_CURLY_BRACKET => 1, T_OPEN_SQUARE_BRACKET => 1, T_CLOSE_SQUARE_BRACKET => 1, T_OPEN_PARENTHESIS => 1, T_CLOSE_PARENTHESIS => 1, T_COLON => 1, T_STRING_CONCAT => 1, T_INLINE_THEN => 1, T_INLINE_ELSE => 1, T_NULLABLE => 1, T_NULL => 4, T_FALSE => 5, T_TRUE => 4, T_SEMICOLON => 1, T_EQUAL => 1, T_MULTIPLY => 1, T_DIVIDE => 1, T_PLUS => 1, T_MINUS => 1, T_MODULUS => 1, T_POW => 2, T_SPACESHIP => 3, T_COALESCE => 2, T_COALESCE_EQUAL => 3, T_BITWISE_AND => 1, T_BITWISE_OR => 1, T_BITWISE_XOR => 1, T_SL => 2, T_SR => 2, T_SL_EQUAL => 3, T_SR_EQUAL => 3, T_GREATER_THAN => 1, T_LESS_THAN => 1, T_BOOLEAN_NOT => 1, T_SELF => 4, T_PARENT => 6, T_COMMA => 1, T_THIS => 4, T_CLOSURE => 8, T_BACKTICK => 1, T_OPEN_SHORT_ARRAY => 1, T_CLOSE_SHORT_ARRAY => 1, ]; /** * A cache of different token types, resolved into arrays. * * @var array * @see standardiseToken() */ private static $resolveTokenCache = []; /** * Creates an array of tokens when given some PHP code. * * Starts by using token_get_all() but does a lot of extra processing * to insert information about the context of the token. * * @param string $string The string to tokenize. * * @return array */ protected function tokenize($string) { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t*** START PHP TOKENIZING ***".PHP_EOL; $isWin = false; if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') { $isWin = true; } } $tokens = @token_get_all($string); $finalTokens = []; $newStackPtr = 0; $numTokens = count($tokens); $lastNotEmptyToken = 0; $insideInlineIf = []; $insideUseGroup = false; $commentTokenizer = new Comment(); for ($stackPtr = 0; $stackPtr < $numTokens; $stackPtr++) { // Special case for tokens we have needed to blank out. if ($tokens[$stackPtr] === null) { continue; } $token = (array) $tokens[$stackPtr]; $tokenIsArray = isset($token[1]); if (PHP_CODESNIFFER_VERBOSITY > 1) { if ($tokenIsArray === true) { $type = Util\Tokens::tokenName($token[0]); $content = Util\Common::prepareForOutput($token[1]); } else { $newToken = self::resolveSimpleToken($token[0]); $type = $newToken['type']; $content = Util\Common::prepareForOutput($token[0]); } echo "\tProcess token "; if ($tokenIsArray === true) { echo "[$stackPtr]"; } else { echo " $stackPtr "; } echo ": $type => $content"; }//end if if ($newStackPtr > 0 && isset(Util\Tokens::$emptyTokens[$finalTokens[($newStackPtr - 1)]['code']]) === false ) { $lastNotEmptyToken = ($newStackPtr - 1); } /* If we are using \r\n newline characters, the \r and \n are sometimes split over two tokens. This normally occurs after comments. We need to merge these two characters together so that our line endings are consistent for all lines. */ if ($tokenIsArray === true && substr($token[1], -1) === "\r") { if (isset($tokens[($stackPtr + 1)]) === true && is_array($tokens[($stackPtr + 1)]) === true && $tokens[($stackPtr + 1)][1][0] === "\n" ) { $token[1] .= "\n"; if (PHP_CODESNIFFER_VERBOSITY > 1) { if ($isWin === true) { echo '\n'; } else { echo "\033[30;1m\\n\033[0m"; } } if ($tokens[($stackPtr + 1)][1] === "\n") { // This token's content has been merged into the previous, // so we can skip it. $tokens[($stackPtr + 1)] = ''; } else { $tokens[($stackPtr + 1)][1] = substr($tokens[($stackPtr + 1)][1], 1); } } }//end if if (PHP_CODESNIFFER_VERBOSITY > 1) { echo PHP_EOL; } /* Parse doc blocks into something that can be easily iterated over. */ if ($tokenIsArray === true && ($token[0] === T_DOC_COMMENT || ($token[0] === T_COMMENT && strpos($token[1], '/**') === 0)) ) { $commentTokens = $commentTokenizer->tokenizeString($token[1], $this->eolChar, $newStackPtr); foreach ($commentTokens as $commentToken) { $finalTokens[$newStackPtr] = $commentToken; $newStackPtr++; } continue; } /* If this is a double quoted string, PHP will tokenize the whole thing which causes problems with the scope map when braces are within the string. So we need to merge the tokens together to provide a single string. */ if ($tokenIsArray === false && ($token[0] === '"' || $token[0] === 'b"')) { // Binary casts need a special token. if ($token[0] === 'b"') { $finalTokens[$newStackPtr] = [ 'code' => T_BINARY_CAST, 'type' => 'T_BINARY_CAST', 'content' => 'b', ]; $newStackPtr++; } $tokenContent = '"'; $nestedVars = []; for ($i = ($stackPtr + 1); $i < $numTokens; $i++) { $subToken = (array) $tokens[$i]; $subTokenIsArray = isset($subToken[1]); if ($subTokenIsArray === true) { $tokenContent .= $subToken[1]; if ($subToken[1] === '{' && $subToken[0] !== T_ENCAPSED_AND_WHITESPACE ) { $nestedVars[] = $i; } } else { $tokenContent .= $subToken[0]; if ($subToken[0] === '}') { array_pop($nestedVars); } } if ($subTokenIsArray === false && $subToken[0] === '"' && empty($nestedVars) === true ) { // We found the other end of the double quoted string. break; } }//end for $stackPtr = $i; // Convert each line within the double quoted string to a // new token, so it conforms with other multiple line tokens. $tokenLines = explode($this->eolChar, $tokenContent); $numLines = count($tokenLines); $newToken = []; for ($j = 0; $j < $numLines; $j++) { $newToken['content'] = $tokenLines[$j]; if ($j === ($numLines - 1)) { if ($tokenLines[$j] === '') { break; } } else { $newToken['content'] .= $this->eolChar; } $newToken['code'] = T_DOUBLE_QUOTED_STRING; $newToken['type'] = 'T_DOUBLE_QUOTED_STRING'; $finalTokens[$newStackPtr] = $newToken; $newStackPtr++; } // Continue, as we're done with this token. continue; }//end if /* Detect binary casting and assign the casts their own token. */ if ($tokenIsArray === true && $token[0] === T_CONSTANT_ENCAPSED_STRING && (substr($token[1], 0, 2) === 'b"' || substr($token[1], 0, 2) === "b'") ) { $finalTokens[$newStackPtr] = [ 'code' => T_BINARY_CAST, 'type' => 'T_BINARY_CAST', 'content' => 'b', ]; $newStackPtr++; $token[1] = substr($token[1], 1); } if ($tokenIsArray === true && $token[0] === T_STRING_CAST && preg_match('`^\(\s*binary\s*\)$`i', $token[1]) === 1 ) { $finalTokens[$newStackPtr] = [ 'code' => T_BINARY_CAST, 'type' => 'T_BINARY_CAST', 'content' => $token[1], ]; $newStackPtr++; continue; } /* If this is a heredoc, PHP will tokenize the whole thing which causes problems when heredocs don't contain real PHP code, which is almost never. We want to leave the start and end heredoc tokens alone though. */ if ($tokenIsArray === true && $token[0] === T_START_HEREDOC) { // Add the start heredoc token to the final array. $finalTokens[$newStackPtr] = self::standardiseToken($token); // Check if this is actually a nowdoc and use a different token // to help the sniffs. $nowdoc = false; if (strpos($token[1], "'") !== false) { $finalTokens[$newStackPtr]['code'] = T_START_NOWDOC; $finalTokens[$newStackPtr]['type'] = 'T_START_NOWDOC'; $nowdoc = true; } $tokenContent = ''; for ($i = ($stackPtr + 1); $i < $numTokens; $i++) { $subTokenIsArray = is_array($tokens[$i]); if ($subTokenIsArray === true && $tokens[$i][0] === T_END_HEREDOC ) { // We found the other end of the heredoc. break; } if ($subTokenIsArray === true) { $tokenContent .= $tokens[$i][1]; } else { $tokenContent .= $tokens[$i]; } } if ($i === $numTokens) { // We got to the end of the file and never // found the closing token, so this probably wasn't // a heredoc. if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $finalTokens[$newStackPtr]['type']; echo "\t\t* failed to find the end of the here/nowdoc".PHP_EOL; echo "\t\t* token $stackPtr changed from $type to T_STRING".PHP_EOL; } $finalTokens[$newStackPtr]['code'] = T_STRING; $finalTokens[$newStackPtr]['type'] = 'T_STRING'; $newStackPtr++; continue; } $stackPtr = $i; $newStackPtr++; // Convert each line within the heredoc to a // new token, so it conforms with other multiple line tokens. $tokenLines = explode($this->eolChar, $tokenContent); $numLines = count($tokenLines); $newToken = []; for ($j = 0; $j < $numLines; $j++) { $newToken['content'] = $tokenLines[$j]; if ($j === ($numLines - 1)) { if ($tokenLines[$j] === '') { break; } } else { $newToken['content'] .= $this->eolChar; } if ($nowdoc === true) { $newToken['code'] = T_NOWDOC; $newToken['type'] = 'T_NOWDOC'; } else { $newToken['code'] = T_HEREDOC; $newToken['type'] = 'T_HEREDOC'; } $finalTokens[$newStackPtr] = $newToken; $newStackPtr++; }//end for // Add the end heredoc token to the final array. $finalTokens[$newStackPtr] = self::standardiseToken($tokens[$stackPtr]); if ($nowdoc === true) { $finalTokens[$newStackPtr]['code'] = T_END_NOWDOC; $finalTokens[$newStackPtr]['type'] = 'T_END_NOWDOC'; } $newStackPtr++; // Continue, as we're done with this token. continue; }//end if /* Before PHP 7.0, the "yield from" was tokenized as T_YIELD, T_WHITESPACE and T_STRING. So look for and change this token in earlier versions. */ if (PHP_VERSION_ID < 70000 && PHP_VERSION_ID >= 50500 && $tokenIsArray === true && $token[0] === T_YIELD && isset($tokens[($stackPtr + 1)]) === true && isset($tokens[($stackPtr + 2)]) === true && $tokens[($stackPtr + 1)][0] === T_WHITESPACE && $tokens[($stackPtr + 2)][0] === T_STRING && strtolower($tokens[($stackPtr + 2)][1]) === 'from' ) { // Could be multi-line, so just the token stack. $token[0] = T_YIELD_FROM; $token[1] .= $tokens[($stackPtr + 1)][1].$tokens[($stackPtr + 2)][1]; if (PHP_CODESNIFFER_VERBOSITY > 1) { for ($i = ($stackPtr + 1); $i <= ($stackPtr + 2); $i++) { $type = Util\Tokens::tokenName($tokens[$i][0]); $content = Util\Common::prepareForOutput($tokens[$i][1]); echo "\t\t* token $i merged into T_YIELD_FROM; was: $type => $content".PHP_EOL; } } $tokens[($stackPtr + 1)] = null; $tokens[($stackPtr + 2)] = null; } /* Before PHP 5.5, the yield keyword was tokenized as T_STRING. So look for and change this token in earlier versions. Checks also if it is just "yield" or "yield from". */ if (PHP_VERSION_ID < 50500 && $tokenIsArray === true && $token[0] === T_STRING && strtolower($token[1]) === 'yield' ) { if (isset($tokens[($stackPtr + 1)]) === true && isset($tokens[($stackPtr + 2)]) === true && $tokens[($stackPtr + 1)][0] === T_WHITESPACE && $tokens[($stackPtr + 2)][0] === T_STRING && strtolower($tokens[($stackPtr + 2)][1]) === 'from' ) { // Could be multi-line, so just just the token stack. $token[0] = T_YIELD_FROM; $token[1] .= $tokens[($stackPtr + 1)][1].$tokens[($stackPtr + 2)][1]; if (PHP_CODESNIFFER_VERBOSITY > 1) { for ($i = ($stackPtr + 1); $i <= ($stackPtr + 2); $i++) { $type = Util\Tokens::tokenName($tokens[$i][0]); $content = Util\Common::prepareForOutput($tokens[$i][1]); echo "\t\t* token $i merged into T_YIELD_FROM; was: $type => $content".PHP_EOL; } } $tokens[($stackPtr + 1)] = null; $tokens[($stackPtr + 2)] = null; } else { $newToken = []; $newToken['code'] = T_YIELD; $newToken['type'] = 'T_YIELD'; $newToken['content'] = $token[1]; $finalTokens[$newStackPtr] = $newToken; $newStackPtr++; continue; }//end if }//end if /* Before PHP 5.6, the ... operator was tokenized as three T_STRING_CONCAT tokens in a row. So look for and combine these tokens in earlier versions. */ if ($tokenIsArray === false && $token[0] === '.' && isset($tokens[($stackPtr + 1)]) === true && isset($tokens[($stackPtr + 2)]) === true && $tokens[($stackPtr + 1)] === '.' && $tokens[($stackPtr + 2)] === '.' ) { $newToken = []; $newToken['code'] = T_ELLIPSIS; $newToken['type'] = 'T_ELLIPSIS'; $newToken['content'] = '...'; $finalTokens[$newStackPtr] = $newToken; $newStackPtr++; $stackPtr += 2; continue; } /* Before PHP 5.6, the ** operator was tokenized as two T_MULTIPLY tokens in a row. So look for and combine these tokens in earlier versions. */ if ($tokenIsArray === false && $token[0] === '*' && isset($tokens[($stackPtr + 1)]) === true && $tokens[($stackPtr + 1)] === '*' ) { $newToken = []; $newToken['code'] = T_POW; $newToken['type'] = 'T_POW'; $newToken['content'] = '**'; $finalTokens[$newStackPtr] = $newToken; $newStackPtr++; $stackPtr++; continue; } /* Before PHP 5.6, the **= operator was tokenized as T_MULTIPLY followed by T_MUL_EQUAL. So look for and combine these tokens in earlier versions. */ if ($tokenIsArray === false && $token[0] === '*' && isset($tokens[($stackPtr + 1)]) === true && is_array($tokens[($stackPtr + 1)]) === true && $tokens[($stackPtr + 1)][1] === '*=' ) { $newToken = []; $newToken['code'] = T_POW_EQUAL; $newToken['type'] = 'T_POW_EQUAL'; $newToken['content'] = '**='; $finalTokens[$newStackPtr] = $newToken; $newStackPtr++; $stackPtr++; continue; } /* Before PHP 7, the ??= operator was tokenized as T_INLINE_THEN, T_INLINE_THEN, T_EQUAL. Between PHP 7.0 and 7.2, the ??= operator was tokenized as T_COALESCE, T_EQUAL. So look for and combine these tokens in earlier versions. */ if (($tokenIsArray === false && $token[0] === '?' && isset($tokens[($stackPtr + 1)]) === true && $tokens[($stackPtr + 1)][0] === '?' && isset($tokens[($stackPtr + 2)]) === true && $tokens[($stackPtr + 2)][0] === '=') || ($tokenIsArray === true && $token[0] === T_COALESCE && isset($tokens[($stackPtr + 1)]) === true && $tokens[($stackPtr + 1)][0] === '=') ) { $newToken = []; $newToken['code'] = T_COALESCE_EQUAL; $newToken['type'] = 'T_COALESCE_EQUAL'; $newToken['content'] = '??='; $finalTokens[$newStackPtr] = $newToken; $newStackPtr++; $stackPtr++; if ($tokenIsArray === false) { // Pre PHP 7. $stackPtr++; } continue; } /* Before PHP 7, the ?? operator was tokenized as T_INLINE_THEN followed by T_INLINE_THEN. So look for and combine these tokens in earlier versions. */ if ($tokenIsArray === false && $token[0] === '?' && isset($tokens[($stackPtr + 1)]) === true && $tokens[($stackPtr + 1)][0] === '?' ) { $newToken = []; $newToken['code'] = T_COALESCE; $newToken['type'] = 'T_COALESCE'; $newToken['content'] = '??'; $finalTokens[$newStackPtr] = $newToken; $newStackPtr++; $stackPtr++; continue; } /* Before PHP 7.4, underscores inside T_LNUMBER and T_DNUMBER tokens split the token with a T_STRING. So look for and change these tokens in earlier versions. */ if (PHP_VERSION_ID < 70400 && ($tokenIsArray === true && ($token[0] === T_LNUMBER || $token[0] === T_DNUMBER) && isset($tokens[($stackPtr + 1)]) === true && is_array($tokens[($stackPtr + 1)]) === true && $tokens[($stackPtr + 1)][0] === T_STRING && $tokens[($stackPtr + 1)][1][0] === '_') ) { $newContent = $token[1]; $newType = $token[0]; for ($i = ($stackPtr + 1); $i < $numTokens; $i++) { if (is_array($tokens[$i]) === false) { break; } if ($tokens[$i][0] === T_LNUMBER || $tokens[$i][0] === T_DNUMBER ) { $newContent .= $tokens[$i][1]; continue; } if ($tokens[$i][0] === T_STRING && $tokens[$i][1][0] === '_' && ((strpos($newContent, '0x') === 0 && preg_match('`^((? PHP_INT_MAX) || (stripos($newContent, '0b') === 0 && bindec(str_replace('_', '', $newContent)) > PHP_INT_MAX) || (stripos($newContent, '0x') !== 0 && stripos($newContent, 'e') !== false || strpos($newContent, '.') !== false) || (strpos($newContent, '0') === 0 && stripos($newContent, '0x') !== 0 && stripos($newContent, '0b') !== 0 && octdec(str_replace('_', '', $newContent)) > PHP_INT_MAX) || (strpos($newContent, '0') !== 0 && str_replace('_', '', $newContent) > PHP_INT_MAX)) ) { $newType = T_DNUMBER; } $newToken = []; $newToken['code'] = $newType; $newToken['type'] = Util\Tokens::tokenName($newType); $newToken['content'] = $newContent; $finalTokens[$newStackPtr] = $newToken; $newStackPtr++; $stackPtr = ($i - 1); continue; }//end if /* Convert ? to T_NULLABLE OR T_INLINE_THEN */ if ($tokenIsArray === false && $token[0] === '?') { $newToken = []; $newToken['content'] = '?'; /* * Check if the next non-empty token is one of the tokens which can be used * in type declarations. If not, it's definitely a ternary. * At this point, the only token types which need to be taken into consideration * as potential type declarations are T_STRING, T_ARRAY, T_CALLABLE and T_NS_SEPARATOR. */ $lastRelevantNonEmpty = null; for ($i = ($stackPtr + 1); $i < $numTokens; $i++) { if (is_array($tokens[$i]) === true) { $tokenType = $tokens[$i][0]; } else { $tokenType = $tokens[$i]; } if (isset(Util\Tokens::$emptyTokens[$tokenType]) === true) { continue; } if ($tokenType === T_STRING || $tokenType === T_ARRAY || $tokenType === T_NS_SEPARATOR ) { $lastRelevantNonEmpty = $tokenType; continue; } if (($tokenType !== T_CALLABLE && isset($lastRelevantNonEmpty) === false) || ($lastRelevantNonEmpty === T_ARRAY && $tokenType === '(') || ($lastRelevantNonEmpty === T_STRING && ($tokenType === T_DOUBLE_COLON || $tokenType === '(' || $tokenType === ':')) ) { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t* token $stackPtr changed from ? to T_INLINE_THEN".PHP_EOL; } $newToken['code'] = T_INLINE_THEN; $newToken['type'] = 'T_INLINE_THEN'; $insideInlineIf[] = $stackPtr; $finalTokens[$newStackPtr] = $newToken; $newStackPtr++; continue 2; } break; }//end for /* * This can still be a nullable type or a ternary. * Do additional checking. */ $prevNonEmpty = null; $lastSeenNonEmpty = null; for ($i = ($stackPtr - 1); $i >= 0; $i--) { if (is_array($tokens[$i]) === true) { $tokenType = $tokens[$i][0]; } else { $tokenType = $tokens[$i]; } if ($tokenType === T_STATIC && ($lastSeenNonEmpty === T_DOUBLE_COLON || $lastSeenNonEmpty === '(') ) { $lastSeenNonEmpty = $tokenType; continue; } if ($prevNonEmpty === null && isset(Util\Tokens::$emptyTokens[$tokenType]) === false ) { // Found the previous non-empty token. if ($tokenType === ':' || $tokenType === ',') { $newToken['code'] = T_NULLABLE; $newToken['type'] = 'T_NULLABLE'; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t* token $stackPtr changed from ? to T_NULLABLE".PHP_EOL; } break; } $prevNonEmpty = $tokenType; } if ($tokenType === T_FUNCTION || $tokenType === T_FN || isset(Util\Tokens::$methodPrefixes[$tokenType]) === true || $tokenType === T_VAR ) { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t* token $stackPtr changed from ? to T_NULLABLE".PHP_EOL; } $newToken['code'] = T_NULLABLE; $newToken['type'] = 'T_NULLABLE'; break; } else if (in_array($tokenType, [T_DOUBLE_ARROW, T_OPEN_TAG, T_OPEN_TAG_WITH_ECHO, '=', '{', ';'], true) === true) { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t* token $stackPtr changed from ? to T_INLINE_THEN".PHP_EOL; } $newToken['code'] = T_INLINE_THEN; $newToken['type'] = 'T_INLINE_THEN'; $insideInlineIf[] = $stackPtr; break; } if (isset(Util\Tokens::$emptyTokens[$tokenType]) === false) { $lastSeenNonEmpty = $tokenType; } }//end for $finalTokens[$newStackPtr] = $newToken; $newStackPtr++; continue; }//end if /* Tokens after a double colon may look like scope openers, such as when writing code like Foo::NAMESPACE, but they are only ever variables or strings. */ if ($stackPtr > 1 && (is_array($tokens[($stackPtr - 1)]) === true && $tokens[($stackPtr - 1)][0] === T_PAAMAYIM_NEKUDOTAYIM) && $tokenIsArray === true && $token[0] !== T_STRING && $token[0] !== T_VARIABLE && $token[0] !== T_DOLLAR && isset(Util\Tokens::$emptyTokens[$token[0]]) === false ) { $newToken = []; $newToken['code'] = T_STRING; $newToken['type'] = 'T_STRING'; $newToken['content'] = $token[1]; $finalTokens[$newStackPtr] = $newToken; $newStackPtr++; continue; } /* Backfill the T_FN token for PHP versions < 7.4. */ if ($tokenIsArray === true && $token[0] === T_STRING && strtolower($token[1]) === 'fn' ) { // Modify the original token stack so that // future checks (like looking for T_NULLABLE) can // detect the T_FN token more easily. $tokens[$stackPtr][0] = T_FN; $token[0] = T_FN; } /* The string-like token after a function keyword should always be tokenized as T_STRING even if it appears to be a different token, such as when writing code like: function default(): foo so go forward and change the token type before it is processed. */ if ($tokenIsArray === true && ($token[0] === T_FUNCTION || $token[0] === T_FN) && $finalTokens[$lastNotEmptyToken]['code'] !== T_USE ) { for ($x = ($stackPtr + 1); $x < $numTokens; $x++) { if (is_array($tokens[$x]) === false || isset(Util\Tokens::$emptyTokens[$tokens[$x][0]]) === false ) { // Non-empty content. break; } } if ($x < $numTokens && is_array($tokens[$x]) === true) { $tokens[$x][0] = T_STRING; } /* This is a special condition for T_ARRAY tokens used for function return types. We want to keep the parenthesis map clean, so let's tag these tokens as T_STRING. */ // Go looking for the colon to start the return type hint. // Start by finding the closing parenthesis of the function. $parenthesisStack = []; $parenthesisCloser = false; for ($x = ($stackPtr + 1); $x < $numTokens; $x++) { if (is_array($tokens[$x]) === false && $tokens[$x] === '(') { $parenthesisStack[] = $x; } else if (is_array($tokens[$x]) === false && $tokens[$x] === ')') { array_pop($parenthesisStack); if (empty($parenthesisStack) === true) { $parenthesisCloser = $x; break; } } } if ($parenthesisCloser !== false) { for ($x = ($parenthesisCloser + 1); $x < $numTokens; $x++) { if (is_array($tokens[$x]) === false || isset(Util\Tokens::$emptyTokens[$tokens[$x][0]]) === false ) { // Non-empty content. if (is_array($tokens[$x]) === true && $tokens[$x][0] === T_USE) { // Found a use statements, so search ahead for the closing parenthesis. for ($x += 1; $x < $numTokens; $x++) { if (is_array($tokens[$x]) === false && $tokens[$x] === ')') { continue(2); } } } break; } } if (isset($tokens[$x]) === true && is_array($tokens[$x]) === false && $tokens[$x] === ':' ) { $allowed = [ T_STRING => T_STRING, T_ARRAY => T_ARRAY, T_CALLABLE => T_CALLABLE, T_SELF => T_SELF, T_PARENT => T_PARENT, T_NS_SEPARATOR => T_NS_SEPARATOR, ]; $allowed += Util\Tokens::$emptyTokens; // Find the start of the return type. for ($x += 1; $x < $numTokens; $x++) { if (is_array($tokens[$x]) === true && isset(Util\Tokens::$emptyTokens[$tokens[$x][0]]) === true ) { // Whitespace or comments before the return type. continue; } if (is_array($tokens[$x]) === false && $tokens[$x] === '?') { // Found a nullable operator, so skip it. // But also covert the token to save the tokenizer // a bit of time later on. $tokens[$x] = [ T_NULLABLE, '?', ]; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t* token $x changed from ? to T_NULLABLE".PHP_EOL; } continue; } break; }//end for // Any T_ARRAY tokens we find between here and the next // token that can't be part of the return type need to be // converted to T_STRING tokens. for ($x; $x < $numTokens; $x++) { if (is_array($tokens[$x]) === false || isset($allowed[$tokens[$x][0]]) === false) { break; } else if ($tokens[$x][0] === T_ARRAY) { $tokens[$x][0] = T_STRING; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t* token $x changed from T_ARRAY to T_STRING".PHP_EOL; } } } }//end if }//end if }//end if /* Before PHP 7, the <=> operator was tokenized as T_IS_SMALLER_OR_EQUAL followed by T_GREATER_THAN. So look for and combine these tokens in earlier versions. */ if ($tokenIsArray === true && $token[0] === T_IS_SMALLER_OR_EQUAL && isset($tokens[($stackPtr + 1)]) === true && $tokens[($stackPtr + 1)][0] === '>' ) { $newToken = []; $newToken['code'] = T_SPACESHIP; $newToken['type'] = 'T_SPACESHIP'; $newToken['content'] = '<=>'; $finalTokens[$newStackPtr] = $newToken; $newStackPtr++; $stackPtr++; continue; } /* PHP doesn't assign a token to goto labels, so we have to. These are just string tokens with a single colon after them. Double colons are already tokenized and so don't interfere with this check. But we do have to account for CASE statements, that look just like goto labels. */ if ($tokenIsArray === true && $token[0] === T_STRING && isset($tokens[($stackPtr + 1)]) === true && $tokens[($stackPtr + 1)] === ':' && $tokens[($stackPtr - 1)][0] !== T_PAAMAYIM_NEKUDOTAYIM ) { $stopTokens = [ T_CASE => true, T_SEMICOLON => true, T_OPEN_CURLY_BRACKET => true, T_INLINE_THEN => true, ]; for ($x = ($newStackPtr - 1); $x > 0; $x--) { if (isset($stopTokens[$finalTokens[$x]['code']]) === true) { break; } } if ($finalTokens[$x]['code'] !== T_CASE && $finalTokens[$x]['code'] !== T_INLINE_THEN ) { $finalTokens[$newStackPtr] = [ 'content' => $token[1].':', 'code' => T_GOTO_LABEL, 'type' => 'T_GOTO_LABEL', ]; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t* token $stackPtr changed from T_STRING to T_GOTO_LABEL".PHP_EOL; echo "\t\t* skipping T_COLON token ".($stackPtr + 1).PHP_EOL; } $newStackPtr++; $stackPtr++; continue; } }//end if /* If this token has newlines in its content, split each line up and create a new token for each line. We do this so it's easier to ascertain where errors occur on a line. Note that $token[1] is the token's content. */ if ($tokenIsArray === true && strpos($token[1], $this->eolChar) !== false) { $tokenLines = explode($this->eolChar, $token[1]); $numLines = count($tokenLines); $newToken = [ 'type' => Util\Tokens::tokenName($token[0]), 'code' => $token[0], 'content' => '', ]; for ($i = 0; $i < $numLines; $i++) { $newToken['content'] = $tokenLines[$i]; if ($i === ($numLines - 1)) { if ($tokenLines[$i] === '') { break; } } else { $newToken['content'] .= $this->eolChar; } $finalTokens[$newStackPtr] = $newToken; $newStackPtr++; } } else { if ($tokenIsArray === true && $token[0] === T_STRING) { // Some T_STRING tokens should remain that way // due to their context. $context = [ T_OBJECT_OPERATOR => true, T_FUNCTION => true, T_CLASS => true, T_EXTENDS => true, T_IMPLEMENTS => true, T_NEW => true, T_CONST => true, T_NS_SEPARATOR => true, T_USE => true, T_NAMESPACE => true, T_PAAMAYIM_NEKUDOTAYIM => true, ]; if (isset($context[$finalTokens[$lastNotEmptyToken]['code']]) === true) { // Special case for syntax like: return new self // where self should not be a string. if ($finalTokens[$lastNotEmptyToken]['code'] === T_NEW && strtolower($token[1]) === 'self' ) { $finalTokens[$newStackPtr] = [ 'content' => $token[1], 'code' => T_SELF, 'type' => 'T_SELF', ]; } else { $finalTokens[$newStackPtr] = [ 'content' => $token[1], 'code' => T_STRING, 'type' => 'T_STRING', ]; } $newStackPtr++; continue; }//end if }//end if $newToken = null; if ($tokenIsArray === false) { if (isset(self::$resolveTokenCache[$token[0]]) === true) { $newToken = self::$resolveTokenCache[$token[0]]; } } else { $cacheKey = null; if ($token[0] === T_STRING) { $cacheKey = strtolower($token[1]); } else if ($token[0] !== T_CURLY_OPEN) { $cacheKey = $token[0]; } if ($cacheKey !== null && isset(self::$resolveTokenCache[$cacheKey]) === true) { $newToken = self::$resolveTokenCache[$cacheKey]; $newToken['content'] = $token[1]; } } if ($newToken === null) { $newToken = self::standardiseToken($token); } // Convert colons that are actually the ELSE component of an // inline IF statement. if (empty($insideInlineIf) === false && $newToken['code'] === T_COLON) { // Make sure this isn't the return type separator of a closure. $isInlineIf = true; for ($i = ($stackPtr - 1); $i > 0; $i--) { if (is_array($tokens[$i]) === false || ($tokens[$i][0] !== T_DOC_COMMENT && $tokens[$i][0] !== T_COMMENT && $tokens[$i][0] !== T_WHITESPACE) ) { break; } } if ($tokens[$i] === ')') { $parenCount = 1; for ($i--; $i > 0; $i--) { if ($tokens[$i] === '(') { $parenCount--; if ($parenCount === 0) { break; } } else if ($tokens[$i] === ')') { $parenCount++; } } // We've found the open parenthesis, so if the previous // non-empty token is FUNCTION or USE, this is a closure. for ($i--; $i > 0; $i--) { if (is_array($tokens[$i]) === false || ($tokens[$i][0] !== T_DOC_COMMENT && $tokens[$i][0] !== T_COMMENT && $tokens[$i][0] !== T_WHITESPACE) ) { break; } } if ($tokens[$i][0] === T_FUNCTION || $tokens[$i][0] === T_FN || $tokens[$i][0] === T_USE) { $isInlineIf = false; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t* token is function return type, not T_INLINE_ELSE".PHP_EOL; } } }//end if // Check to see if this is a CASE or DEFAULT opener. $inlineIfToken = $insideInlineIf[(count($insideInlineIf) - 1)]; for ($i = $stackPtr; $i > $inlineIfToken; $i--) { if (is_array($tokens[$i]) === true && ($tokens[$i][0] === T_CASE || $tokens[$i][0] === T_DEFAULT) ) { $isInlineIf = false; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t* token is T_CASE or T_DEFAULT opener, not T_INLINE_ELSE".PHP_EOL; } break; } if (is_array($tokens[$i]) === false && ($tokens[$i] === ';' || $tokens[$i] === '{') ) { break; } } if ($isInlineIf === true) { array_pop($insideInlineIf); $newToken['code'] = T_INLINE_ELSE; $newToken['type'] = 'T_INLINE_ELSE'; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t* token changed from T_COLON to T_INLINE_ELSE".PHP_EOL; } } }//end if // This is a special condition for T_ARRAY tokens used for // type hinting function arguments as being arrays. We want to keep // the parenthesis map clean, so let's tag these tokens as // T_STRING. if ($newToken['code'] === T_ARRAY) { for ($i = $stackPtr; $i < $numTokens; $i++) { if ($tokens[$i] === '(') { break; } else if ($tokens[$i][0] === T_VARIABLE) { $newToken['code'] = T_STRING; $newToken['type'] = 'T_STRING'; break; } } } // This is a special case when checking PHP 5.5+ code in PHP < 5.5 // where "finally" should be T_FINALLY instead of T_STRING. if ($newToken['code'] === T_STRING && strtolower($newToken['content']) === 'finally' ) { $newToken['code'] = T_FINALLY; $newToken['type'] = 'T_FINALLY'; } // This is a special case for the PHP 5.5 classname::class syntax // where "class" should be T_STRING instead of T_CLASS. if (($newToken['code'] === T_CLASS || $newToken['code'] === T_FUNCTION) && $finalTokens[$lastNotEmptyToken]['code'] === T_DOUBLE_COLON ) { $newToken['code'] = T_STRING; $newToken['type'] = 'T_STRING'; } // This is a special case for PHP 5.6 use function and use const // where "function" and "const" should be T_STRING instead of T_FUNCTION // and T_CONST. if (($newToken['code'] === T_FUNCTION || $newToken['code'] === T_CONST) && ($finalTokens[$lastNotEmptyToken]['code'] === T_USE || $insideUseGroup === true) ) { $newToken['code'] = T_STRING; $newToken['type'] = 'T_STRING'; } // This is a special case for use groups in PHP 7+ where leaving // the curly braces as their normal tokens would confuse // the scope map and sniffs. if ($newToken['code'] === T_OPEN_CURLY_BRACKET && $finalTokens[$lastNotEmptyToken]['code'] === T_NS_SEPARATOR ) { $newToken['code'] = T_OPEN_USE_GROUP; $newToken['type'] = 'T_OPEN_USE_GROUP'; $insideUseGroup = true; } if ($insideUseGroup === true && $newToken['code'] === T_CLOSE_CURLY_BRACKET) { $newToken['code'] = T_CLOSE_USE_GROUP; $newToken['type'] = 'T_CLOSE_USE_GROUP'; $insideUseGroup = false; } $finalTokens[$newStackPtr] = $newToken; $newStackPtr++; }//end if }//end for if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t*** END PHP TOKENIZING ***".PHP_EOL; } return $finalTokens; }//end tokenize() /** * Performs additional processing after main tokenizing. * * This additional processing checks for CASE statements that are using curly * braces for scope openers and closers. It also turns some T_FUNCTION tokens * into T_CLOSURE when they are not standard function definitions. It also * detects short array syntax and converts those square brackets into new tokens. * It also corrects some usage of the static and class keywords. It also * assigns tokens to function return types. * * @return void */ protected function processAdditional() { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t*** START ADDITIONAL PHP PROCESSING ***".PHP_EOL; } $numTokens = count($this->tokens); for ($i = ($numTokens - 1); $i >= 0; $i--) { // Check for any unset scope conditions due to alternate IF/ENDIF syntax. if (isset($this->tokens[$i]['scope_opener']) === true && isset($this->tokens[$i]['scope_condition']) === false ) { $this->tokens[$i]['scope_condition'] = $this->tokens[$this->tokens[$i]['scope_opener']]['scope_condition']; } if ($this->tokens[$i]['code'] === T_FUNCTION) { /* Detect functions that are actually closures and assign them a different token. */ if (isset($this->tokens[$i]['scope_opener']) === true) { for ($x = ($i + 1); $x < $numTokens; $x++) { if (isset(Util\Tokens::$emptyTokens[$this->tokens[$x]['code']]) === false && $this->tokens[$x]['code'] !== T_BITWISE_AND ) { break; } } if ($this->tokens[$x]['code'] === T_OPEN_PARENTHESIS) { $this->tokens[$i]['code'] = T_CLOSURE; $this->tokens[$i]['type'] = 'T_CLOSURE'; if (PHP_CODESNIFFER_VERBOSITY > 1) { $line = $this->tokens[$i]['line']; echo "\t* token $i on line $line changed from T_FUNCTION to T_CLOSURE".PHP_EOL; } for ($x = ($this->tokens[$i]['scope_opener'] + 1); $x < $this->tokens[$i]['scope_closer']; $x++) { if (isset($this->tokens[$x]['conditions'][$i]) === false) { continue; } $this->tokens[$x]['conditions'][$i] = T_CLOSURE; if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$x]['type']; echo "\t\t* cleaned $x ($type) *".PHP_EOL; } } } }//end if continue; } else if ($this->tokens[$i]['code'] === T_CLASS && isset($this->tokens[$i]['scope_opener']) === true) { /* Detect anonymous classes and assign them a different token. */ for ($x = ($i + 1); $x < $numTokens; $x++) { if (isset(Util\Tokens::$emptyTokens[$this->tokens[$x]['code']]) === false) { break; } } if ($this->tokens[$x]['code'] === T_OPEN_PARENTHESIS || $this->tokens[$x]['code'] === T_OPEN_CURLY_BRACKET || $this->tokens[$x]['code'] === T_EXTENDS || $this->tokens[$x]['code'] === T_IMPLEMENTS ) { $this->tokens[$i]['code'] = T_ANON_CLASS; $this->tokens[$i]['type'] = 'T_ANON_CLASS'; if (PHP_CODESNIFFER_VERBOSITY > 1) { $line = $this->tokens[$i]['line']; echo "\t* token $i on line $line changed from T_CLASS to T_ANON_CLASS".PHP_EOL; } if ($this->tokens[$x]['code'] === T_OPEN_PARENTHESIS && isset($this->tokens[$x]['parenthesis_closer']) === true ) { $closer = $this->tokens[$x]['parenthesis_closer']; $this->tokens[$i]['parenthesis_opener'] = $x; $this->tokens[$i]['parenthesis_closer'] = $closer; $this->tokens[$i]['parenthesis_owner'] = $i; $this->tokens[$x]['parenthesis_owner'] = $i; $this->tokens[$closer]['parenthesis_owner'] = $i; if (PHP_CODESNIFFER_VERBOSITY > 1) { $line = $this->tokens[$i]['line']; echo "\t\t* added parenthesis keys to T_ANON_CLASS token $i on line $line".PHP_EOL; } } for ($x = ($this->tokens[$i]['scope_opener'] + 1); $x < $this->tokens[$i]['scope_closer']; $x++) { if (isset($this->tokens[$x]['conditions'][$i]) === false) { continue; } $this->tokens[$x]['conditions'][$i] = T_ANON_CLASS; if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$x]['type']; echo "\t\t* cleaned $x ($type) *".PHP_EOL; } } }//end if continue; } else if ($this->tokens[$i]['code'] === T_FN && isset($this->tokens[($i + 1)]) === true) { // Possible arrow function. for ($x = ($i + 1); $x < $numTokens; $x++) { if (isset(Util\Tokens::$emptyTokens[$this->tokens[$x]['code']]) === false && $this->tokens[$x]['code'] !== T_BITWISE_AND ) { // Non-whitespace content. break; } } if (isset($this->tokens[$x]) === true && $this->tokens[$x]['code'] === T_OPEN_PARENTHESIS) { $ignore = Util\Tokens::$emptyTokens; $ignore += [ T_STRING => T_STRING, T_ARRAY => T_ARRAY, T_COLON => T_COLON, T_NS_SEPARATOR => T_NS_SEPARATOR, T_NULLABLE => T_NULLABLE, T_CALLABLE => T_CALLABLE, T_PARENT => T_PARENT, T_SELF => T_SELF, ]; $closer = $this->tokens[$x]['parenthesis_closer']; for ($arrow = ($closer + 1); $arrow < $numTokens; $arrow++) { if (isset($ignore[$this->tokens[$arrow]['code']]) === false) { break; } } if ($this->tokens[$arrow]['code'] === T_DOUBLE_ARROW) { $endTokens = [ T_COLON => true, T_COMMA => true, T_SEMICOLON => true, T_CLOSE_PARENTHESIS => true, T_CLOSE_SQUARE_BRACKET => true, T_CLOSE_CURLY_BRACKET => true, T_CLOSE_SHORT_ARRAY => true, T_OPEN_TAG => true, T_CLOSE_TAG => true, ]; $inTernary = false; for ($scopeCloser = ($arrow + 1); $scopeCloser < $numTokens; $scopeCloser++) { if (isset($endTokens[$this->tokens[$scopeCloser]['code']]) === true) { break; } if (isset($this->tokens[$scopeCloser]['scope_closer']) === true && $this->tokens[$scopeCloser]['code'] !== T_INLINE_ELSE ) { // We minus 1 here in case the closer can be shared with us. $scopeCloser = ($this->tokens[$scopeCloser]['scope_closer'] - 1); continue; } if (isset($this->tokens[$scopeCloser]['parenthesis_closer']) === true) { $scopeCloser = $this->tokens[$scopeCloser]['parenthesis_closer']; continue; } if (isset($this->tokens[$scopeCloser]['bracket_closer']) === true) { $scopeCloser = $this->tokens[$scopeCloser]['bracket_closer']; continue; } if ($this->tokens[$scopeCloser]['code'] === T_INLINE_THEN) { $inTernary = true; continue; } if ($this->tokens[$scopeCloser]['code'] === T_INLINE_ELSE) { if ($inTernary === false) { break; } $inTernary = false; continue; } }//end for if ($scopeCloser !== $numTokens) { if (PHP_CODESNIFFER_VERBOSITY > 1) { $line = $this->tokens[$i]['line']; echo "\t=> token $i on line $line processed as arrow function".PHP_EOL; } $this->tokens[$i]['code'] = T_FN; $this->tokens[$i]['type'] = 'T_FN'; $this->tokens[$i]['scope_condition'] = $i; $this->tokens[$i]['scope_opener'] = $arrow; $this->tokens[$i]['scope_closer'] = $scopeCloser; $this->tokens[$i]['parenthesis_owner'] = $i; $this->tokens[$i]['parenthesis_opener'] = $x; $this->tokens[$i]['parenthesis_closer'] = $this->tokens[$x]['parenthesis_closer']; $this->tokens[$arrow]['code'] = T_FN_ARROW; $this->tokens[$arrow]['type'] = 'T_FN_ARROW'; $this->tokens[$arrow]['scope_condition'] = $i; $this->tokens[$arrow]['scope_opener'] = $arrow; $this->tokens[$arrow]['scope_closer'] = $scopeCloser; $this->tokens[$scopeCloser]['scope_condition'] = $i; $this->tokens[$scopeCloser]['scope_opener'] = $arrow; $this->tokens[$scopeCloser]['scope_closer'] = $scopeCloser; $opener = $this->tokens[$i]['parenthesis_opener']; $closer = $this->tokens[$i]['parenthesis_closer']; $this->tokens[$opener]['parenthesis_owner'] = $i; $this->tokens[$closer]['parenthesis_owner'] = $i; if (PHP_CODESNIFFER_VERBOSITY > 1) { $line = $this->tokens[$arrow]['line']; echo "\t\t* token $arrow on line $line changed from T_DOUBLE_ARROW to T_FN_ARROW".PHP_EOL; } }//end if }//end if }//end if } else if ($this->tokens[$i]['code'] === T_OPEN_SQUARE_BRACKET) { if (isset($this->tokens[$i]['bracket_closer']) === false) { continue; } // Unless there is a variable or a bracket before this token, // it is the start of an array being defined using the short syntax. $isShortArray = false; $allowed = [ T_CLOSE_SQUARE_BRACKET => T_CLOSE_SQUARE_BRACKET, T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET, T_CLOSE_PARENTHESIS => T_CLOSE_PARENTHESIS, T_VARIABLE => T_VARIABLE, T_OBJECT_OPERATOR => T_OBJECT_OPERATOR, T_STRING => T_STRING, T_CONSTANT_ENCAPSED_STRING => T_CONSTANT_ENCAPSED_STRING, ]; for ($x = ($i - 1); $x >= 0; $x--) { // If we hit a scope opener, the statement has ended // without finding anything, so it's probably an array // using PHP 7.1 short list syntax. if (isset($this->tokens[$x]['scope_opener']) === true) { $isShortArray = true; break; } if (isset(Util\Tokens::$emptyTokens[$this->tokens[$x]['code']]) === false) { if (isset($allowed[$this->tokens[$x]['code']]) === false) { $isShortArray = true; } break; } } if ($isShortArray === true) { $this->tokens[$i]['code'] = T_OPEN_SHORT_ARRAY; $this->tokens[$i]['type'] = 'T_OPEN_SHORT_ARRAY'; $closer = $this->tokens[$i]['bracket_closer']; $this->tokens[$closer]['code'] = T_CLOSE_SHORT_ARRAY; $this->tokens[$closer]['type'] = 'T_CLOSE_SHORT_ARRAY'; if (PHP_CODESNIFFER_VERBOSITY > 1) { $line = $this->tokens[$i]['line']; echo "\t* token $i on line $line changed from T_OPEN_SQUARE_BRACKET to T_OPEN_SHORT_ARRAY".PHP_EOL; $line = $this->tokens[$closer]['line']; echo "\t* token $closer on line $line changed from T_CLOSE_SQUARE_BRACKET to T_CLOSE_SHORT_ARRAY".PHP_EOL; } } continue; } else if ($this->tokens[$i]['code'] === T_STATIC) { for ($x = ($i - 1); $x > 0; $x--) { if (isset(Util\Tokens::$emptyTokens[$this->tokens[$x]['code']]) === false) { break; } } if ($this->tokens[$x]['code'] === T_INSTANCEOF) { $this->tokens[$i]['code'] = T_STRING; $this->tokens[$i]['type'] = 'T_STRING'; if (PHP_CODESNIFFER_VERBOSITY > 1) { $line = $this->tokens[$i]['line']; echo "\t* token $i on line $line changed from T_STATIC to T_STRING".PHP_EOL; } } continue; } else if ($this->tokens[$i]['code'] === T_TRUE || $this->tokens[$i]['code'] === T_FALSE || $this->tokens[$i]['code'] === T_NULL ) { for ($x = ($i + 1); $i < $numTokens; $x++) { if (isset(Util\Tokens::$emptyTokens[$this->tokens[$x]['code']]) === false) { // Non-whitespace content. break; } } $context = [ T_OBJECT_OPERATOR => true, T_NS_SEPARATOR => true, T_PAAMAYIM_NEKUDOTAYIM => true, ]; if (isset($context[$this->tokens[$x]['code']]) === true) { if (PHP_CODESNIFFER_VERBOSITY > 1) { $line = $this->tokens[$i]['line']; $type = $this->tokens[$i]['type']; echo "\t* token $i on line $line changed from $type to T_STRING".PHP_EOL; } $this->tokens[$i]['code'] = T_STRING; $this->tokens[$i]['type'] = 'T_STRING'; } } else if ($this->tokens[$i]['code'] === T_CONST) { // Context sensitive keywords support. for ($x = ($i + 1); $i < $numTokens; $x++) { if (isset(Util\Tokens::$emptyTokens[$this->tokens[$x]['code']]) === false) { // Non-whitespace content. break; } } if ($this->tokens[$x]['code'] !== T_STRING) { if (PHP_CODESNIFFER_VERBOSITY > 1) { $line = $this->tokens[$x]['line']; $type = $this->tokens[$x]['type']; echo "\t* token $x on line $line changed from $type to T_STRING".PHP_EOL; } $this->tokens[$x]['code'] = T_STRING; $this->tokens[$x]['type'] = 'T_STRING'; } }//end if if (($this->tokens[$i]['code'] !== T_CASE && $this->tokens[$i]['code'] !== T_DEFAULT) || isset($this->tokens[$i]['scope_opener']) === false ) { // Only interested in CASE and DEFAULT statements from here on in. continue; } $scopeOpener = $this->tokens[$i]['scope_opener']; $scopeCloser = $this->tokens[$i]['scope_closer']; // If the first char after the opener is a curly brace // and that brace has been ignored, it is actually // opening this case statement and the opener and closer are // probably set incorrectly. for ($x = ($scopeOpener + 1); $x < $numTokens; $x++) { if (isset(Util\Tokens::$emptyTokens[$this->tokens[$x]['code']]) === false) { // Non-whitespace content. break; } } if ($this->tokens[$x]['code'] === T_CASE || $this->tokens[$x]['code'] === T_DEFAULT) { // Special case for multiple CASE statements that share the same // closer. Because we are going backwards through the file, this next // CASE statement is already fixed, so just use its closer and don't // worry about fixing anything. $newCloser = $this->tokens[$x]['scope_closer']; $this->tokens[$i]['scope_closer'] = $newCloser; if (PHP_CODESNIFFER_VERBOSITY > 1) { $oldType = $this->tokens[$scopeCloser]['type']; $newType = $this->tokens[$newCloser]['type']; $line = $this->tokens[$i]['line']; echo "\t* token $i (T_CASE) on line $line closer changed from $scopeCloser ($oldType) to $newCloser ($newType)".PHP_EOL; } continue; } if ($this->tokens[$x]['code'] !== T_OPEN_CURLY_BRACKET || isset($this->tokens[$x]['scope_condition']) === true ) { // Not a CASE/DEFAULT with a curly brace opener. continue; } // The closer for this CASE/DEFAULT should be the closing curly brace and // not whatever it already is. The opener needs to be the opening curly // brace so everything matches up. $newCloser = $this->tokens[$x]['bracket_closer']; foreach ([$i, $x, $newCloser] as $index) { $this->tokens[$index]['scope_condition'] = $i; $this->tokens[$index]['scope_opener'] = $x; $this->tokens[$index]['scope_closer'] = $newCloser; } if (PHP_CODESNIFFER_VERBOSITY > 1) { $line = $this->tokens[$i]['line']; $tokenType = $this->tokens[$i]['type']; $oldType = $this->tokens[$scopeOpener]['type']; $newType = $this->tokens[$x]['type']; echo "\t* token $i ($tokenType) on line $line opener changed from $scopeOpener ($oldType) to $x ($newType)".PHP_EOL; $oldType = $this->tokens[$scopeCloser]['type']; $newType = $this->tokens[$newCloser]['type']; echo "\t* token $i ($tokenType) on line $line closer changed from $scopeCloser ($oldType) to $newCloser ($newType)".PHP_EOL; } if ($this->tokens[$scopeOpener]['scope_condition'] === $i) { unset($this->tokens[$scopeOpener]['scope_condition']); unset($this->tokens[$scopeOpener]['scope_opener']); unset($this->tokens[$scopeOpener]['scope_closer']); } if ($this->tokens[$scopeCloser]['scope_condition'] === $i) { unset($this->tokens[$scopeCloser]['scope_condition']); unset($this->tokens[$scopeCloser]['scope_opener']); unset($this->tokens[$scopeCloser]['scope_closer']); } else { // We were using a shared closer. All tokens that were // sharing this closer with us, except for the scope condition // and it's opener, need to now point to the new closer. $condition = $this->tokens[$scopeCloser]['scope_condition']; $start = ($this->tokens[$condition]['scope_opener'] + 1); for ($y = $start; $y < $scopeCloser; $y++) { if (isset($this->tokens[$y]['scope_closer']) === true && $this->tokens[$y]['scope_closer'] === $scopeCloser ) { $this->tokens[$y]['scope_closer'] = $newCloser; if (PHP_CODESNIFFER_VERBOSITY > 1) { $line = $this->tokens[$y]['line']; $tokenType = $this->tokens[$y]['type']; $oldType = $this->tokens[$scopeCloser]['type']; $newType = $this->tokens[$newCloser]['type']; echo "\t\t* token $y ($tokenType) on line $line closer changed from $scopeCloser ($oldType) to $newCloser ($newType)".PHP_EOL; } } } }//end if unset($this->tokens[$x]['bracket_opener']); unset($this->tokens[$x]['bracket_closer']); unset($this->tokens[$newCloser]['bracket_opener']); unset($this->tokens[$newCloser]['bracket_closer']); $this->tokens[$scopeCloser]['conditions'][] = $i; // Now fix up all the tokens that think they are // inside the CASE/DEFAULT statement when they are really outside. for ($x = $newCloser; $x < $scopeCloser; $x++) { foreach ($this->tokens[$x]['conditions'] as $num => $oldCond) { if ($oldCond === $this->tokens[$i]['code']) { $oldConditions = $this->tokens[$x]['conditions']; unset($this->tokens[$x]['conditions'][$num]); if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$x]['type']; $oldConds = ''; foreach ($oldConditions as $condition) { $oldConds .= Util\Tokens::tokenName($condition).','; } $oldConds = rtrim($oldConds, ','); $newConds = ''; foreach ($this->tokens[$x]['conditions'] as $condition) { $newConds .= Util\Tokens::tokenName($condition).','; } $newConds = rtrim($newConds, ','); echo "\t\t* cleaned $x ($type) *".PHP_EOL; echo "\t\t\t=> conditions changed from $oldConds to $newConds".PHP_EOL; } break; }//end if }//end foreach }//end for }//end for if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t*** END ADDITIONAL PHP PROCESSING ***".PHP_EOL; } }//end processAdditional() /** * Takes a token produced from token_get_all() and produces a * more uniform token. * * @param string|array $token The token to convert. * * @return array The new token. */ public static function standardiseToken($token) { if (isset($token[1]) === false) { if (isset(self::$resolveTokenCache[$token[0]]) === true) { return self::$resolveTokenCache[$token[0]]; } } else { $cacheKey = null; if ($token[0] === T_STRING) { $cacheKey = strtolower($token[1]); } else if ($token[0] !== T_CURLY_OPEN) { $cacheKey = $token[0]; } if ($cacheKey !== null && isset(self::$resolveTokenCache[$cacheKey]) === true) { $newToken = self::$resolveTokenCache[$cacheKey]; $newToken['content'] = $token[1]; return $newToken; } } if (isset($token[1]) === false) { return self::resolveSimpleToken($token[0]); } if ($token[0] === T_STRING) { switch ($cacheKey) { case 'false': $newToken['type'] = 'T_FALSE'; break; case 'true': $newToken['type'] = 'T_TRUE'; break; case 'null': $newToken['type'] = 'T_NULL'; break; case 'self': $newToken['type'] = 'T_SELF'; break; case 'parent': $newToken['type'] = 'T_PARENT'; break; default: $newToken['type'] = 'T_STRING'; break; } $newToken['code'] = constant($newToken['type']); self::$resolveTokenCache[$cacheKey] = $newToken; } else if ($token[0] === T_CURLY_OPEN) { $newToken = [ 'code' => T_OPEN_CURLY_BRACKET, 'type' => 'T_OPEN_CURLY_BRACKET', ]; } else { $newToken = [ 'code' => $token[0], 'type' => Util\Tokens::tokenName($token[0]), ]; self::$resolveTokenCache[$token[0]] = $newToken; }//end if $newToken['content'] = $token[1]; return $newToken; }//end standardiseToken() /** * Converts simple tokens into a format that conforms to complex tokens * produced by token_get_all(). * * Simple tokens are tokens that are not in array form when produced from * token_get_all(). * * @param string $token The simple token to convert. * * @return array The new token in array format. */ public static function resolveSimpleToken($token) { $newToken = []; switch ($token) { case '{': $newToken['type'] = 'T_OPEN_CURLY_BRACKET'; break; case '}': $newToken['type'] = 'T_CLOSE_CURLY_BRACKET'; break; case '[': $newToken['type'] = 'T_OPEN_SQUARE_BRACKET'; break; case ']': $newToken['type'] = 'T_CLOSE_SQUARE_BRACKET'; break; case '(': $newToken['type'] = 'T_OPEN_PARENTHESIS'; break; case ')': $newToken['type'] = 'T_CLOSE_PARENTHESIS'; break; case ':': $newToken['type'] = 'T_COLON'; break; case '.': $newToken['type'] = 'T_STRING_CONCAT'; break; case ';': $newToken['type'] = 'T_SEMICOLON'; break; case '=': $newToken['type'] = 'T_EQUAL'; break; case '*': $newToken['type'] = 'T_MULTIPLY'; break; case '/': $newToken['type'] = 'T_DIVIDE'; break; case '+': $newToken['type'] = 'T_PLUS'; break; case '-': $newToken['type'] = 'T_MINUS'; break; case '%': $newToken['type'] = 'T_MODULUS'; break; case '^': $newToken['type'] = 'T_BITWISE_XOR'; break; case '&': $newToken['type'] = 'T_BITWISE_AND'; break; case '|': $newToken['type'] = 'T_BITWISE_OR'; break; case '~': $newToken['type'] = 'T_BITWISE_NOT'; break; case '<': $newToken['type'] = 'T_LESS_THAN'; break; case '>': $newToken['type'] = 'T_GREATER_THAN'; break; case '!': $newToken['type'] = 'T_BOOLEAN_NOT'; break; case ',': $newToken['type'] = 'T_COMMA'; break; case '@': $newToken['type'] = 'T_ASPERAND'; break; case '$': $newToken['type'] = 'T_DOLLAR'; break; case '`': $newToken['type'] = 'T_BACKTICK'; break; default: $newToken['type'] = 'T_NONE'; break; }//end switch $newToken['code'] = constant($newToken['type']); $newToken['content'] = $token; self::$resolveTokenCache[$token] = $newToken; return $newToken; }//end resolveSimpleToken() }//end class PHP_CodeSniffer-3.5.4/src/Tokenizers/Tokenizer.php0000644000076500000240000022552313614652362021735 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Tokenizers; use PHP_CodeSniffer\Exceptions\TokenizerException; use PHP_CodeSniffer\Util; abstract class Tokenizer { /** * The config data for the run. * * @var \PHP_CodeSniffer\Config */ protected $config = null; /** * The EOL char used in the content. * * @var string */ protected $eolChar = []; /** * A token-based representation of the content. * * @var array */ protected $tokens = []; /** * The number of tokens in the tokens array. * * @var integer */ protected $numTokens = 0; /** * A list of tokens that are allowed to open a scope. * * @var array */ public $scopeOpeners = []; /** * A list of tokens that end the scope. * * @var array */ public $endScopeTokens = []; /** * Known lengths of tokens. * * @var array */ public $knownLengths = []; /** * A list of lines being ignored due to error suppression comments. * * @var array */ public $ignoredLines = []; /** * Initialise and run the tokenizer. * * @param string $content The content to tokenize, * @param \PHP_CodeSniffer\Config | null $config The config data for the run. * @param string $eolChar The EOL char used in the content. * * @return void * @throws \PHP_CodeSniffer\Exceptions\TokenizerException If the file appears to be minified. */ public function __construct($content, $config, $eolChar='\n') { $this->eolChar = $eolChar; $this->config = $config; $this->tokens = $this->tokenize($content); if ($config === null) { return; } $this->createPositionMap(); $this->createTokenMap(); $this->createParenthesisNestingMap(); $this->createScopeMap(); $this->createLevelMap(); // Allow the tokenizer to do additional processing if required. $this->processAdditional(); }//end __construct() /** * Checks the content to see if it looks minified. * * @param string $content The content to tokenize. * @param string $eolChar The EOL char used in the content. * * @return boolean */ protected function isMinifiedContent($content, $eolChar='\n') { // Minified files often have a very large number of characters per line // and cause issues when tokenizing. $numChars = strlen($content); $numLines = (substr_count($content, $eolChar) + 1); $average = ($numChars / $numLines); if ($average > 100) { return true; } return false; }//end isMinifiedContent() /** * Gets the array of tokens. * * @return array */ public function getTokens() { return $this->tokens; }//end getTokens() /** * Creates an array of tokens when given some content. * * @param string $string The string to tokenize. * * @return array */ abstract protected function tokenize($string); /** * Performs additional processing after main tokenizing. * * @return void */ abstract protected function processAdditional(); /** * Sets token position information. * * Can also convert tabs into spaces. Each tab can represent between * 1 and $width spaces, so this cannot be a straight string replace. * * @return void */ private function createPositionMap() { $currColumn = 1; $lineNumber = 1; $eolLen = strlen($this->eolChar); $ignoring = null; $inTests = defined('PHP_CODESNIFFER_IN_TESTS'); $checkEncoding = false; if (function_exists('iconv_strlen') === true) { $checkEncoding = true; } $checkAnnotations = $this->config->annotations; $encoding = $this->config->encoding; $tabWidth = $this->config->tabWidth; $tokensWithTabs = [ T_WHITESPACE => true, T_COMMENT => true, T_DOC_COMMENT => true, T_DOC_COMMENT_WHITESPACE => true, T_DOC_COMMENT_STRING => true, T_CONSTANT_ENCAPSED_STRING => true, T_DOUBLE_QUOTED_STRING => true, T_HEREDOC => true, T_NOWDOC => true, T_INLINE_HTML => true, ]; $this->numTokens = count($this->tokens); for ($i = 0; $i < $this->numTokens; $i++) { $this->tokens[$i]['line'] = $lineNumber; $this->tokens[$i]['column'] = $currColumn; if (isset($this->knownLengths[$this->tokens[$i]['code']]) === true) { // There are no tabs in the tokens we know the length of. $length = $this->knownLengths[$this->tokens[$i]['code']]; $currColumn += $length; } else if ($tabWidth === 0 || isset($tokensWithTabs[$this->tokens[$i]['code']]) === false || strpos($this->tokens[$i]['content'], "\t") === false ) { // There are no tabs in this content, or we aren't replacing them. if ($checkEncoding === true) { // Not using the default encoding, so take a bit more care. $oldLevel = error_reporting(); error_reporting(0); $length = iconv_strlen($this->tokens[$i]['content'], $encoding); error_reporting($oldLevel); if ($length === false) { // String contained invalid characters, so revert to default. $length = strlen($this->tokens[$i]['content']); } } else { $length = strlen($this->tokens[$i]['content']); } $currColumn += $length; } else { $this->replaceTabsInToken($this->tokens[$i]); $length = $this->tokens[$i]['length']; $currColumn += $length; }//end if $this->tokens[$i]['length'] = $length; if (isset($this->knownLengths[$this->tokens[$i]['code']]) === false && strpos($this->tokens[$i]['content'], $this->eolChar) !== false ) { $lineNumber++; $currColumn = 1; // Newline chars are not counted in the token length. $this->tokens[$i]['length'] -= $eolLen; } if ($this->tokens[$i]['code'] === T_COMMENT || $this->tokens[$i]['code'] === T_DOC_COMMENT_STRING || $this->tokens[$i]['code'] === T_DOC_COMMENT_TAG || ($inTests === true && $this->tokens[$i]['code'] === T_INLINE_HTML) ) { $commentText = ltrim($this->tokens[$i]['content'], " \t/*"); $commentText = rtrim($commentText, " */\t\r\n"); $commentTextLower = strtolower($commentText); if (strpos($commentText, '@codingStandards') !== false) { // If this comment is the only thing on the line, it tells us // to ignore the following line. If the line contains other content // then we are just ignoring this one single line. $ownLine = false; if ($i > 0) { for ($prev = ($i - 1); $prev >= 0; $prev--) { if ($this->tokens[$prev]['code'] === T_WHITESPACE) { continue; } break; } if ($this->tokens[$prev]['line'] !== $this->tokens[$i]['line']) { $ownLine = true; } } if ($ignoring === null && strpos($commentText, '@codingStandardsIgnoreStart') !== false ) { $ignoring = ['.all' => true]; if ($ownLine === true) { $this->ignoredLines[$this->tokens[$i]['line']] = $ignoring; } } else if ($ignoring !== null && strpos($commentText, '@codingStandardsIgnoreEnd') !== false ) { if ($ownLine === true) { $this->ignoredLines[$this->tokens[$i]['line']] = ['.all' => true]; } else { $this->ignoredLines[$this->tokens[$i]['line']] = $ignoring; } $ignoring = null; } else if ($ignoring === null && strpos($commentText, '@codingStandardsIgnoreLine') !== false ) { $ignoring = ['.all' => true]; if ($ownLine === true) { $this->ignoredLines[$this->tokens[$i]['line']] = $ignoring; $this->ignoredLines[($this->tokens[$i]['line'] + 1)] = $ignoring; } else { $this->ignoredLines[$this->tokens[$i]['line']] = $ignoring; } $ignoring = null; }//end if } else if (substr($commentTextLower, 0, 6) === 'phpcs:' || substr($commentTextLower, 0, 7) === '@phpcs:' ) { // If the @phpcs: syntax is being used, strip the @ to make // comparisons easier. if ($commentText[0] === '@') { $commentText = substr($commentText, 1); $commentTextLower = strtolower($commentText); } // If there is a comment on the end, strip it off. $commentStart = strpos($commentTextLower, ' --'); if ($commentStart !== false) { $commentText = substr($commentText, 0, $commentStart); $commentTextLower = strtolower($commentText); } // If this comment is the only thing on the line, it tells us // to ignore the following line. If the line contains other content // then we are just ignoring this one single line. $lineHasOtherContent = false; $lineHasOtherTokens = false; if ($i > 0) { for ($prev = ($i - 1); $prev > 0; $prev--) { if ($this->tokens[$prev]['line'] !== $this->tokens[$i]['line']) { // Changed lines. break; } if ($this->tokens[$prev]['code'] === T_WHITESPACE || ($this->tokens[$prev]['code'] === T_INLINE_HTML && trim($this->tokens[$prev]['content']) === '') ) { continue; } $lineHasOtherTokens = true; if ($this->tokens[$prev]['code'] === T_OPEN_TAG) { continue; } $lineHasOtherContent = true; break; }//end for $changedLines = false; for ($next = $i; $next < $this->numTokens; $next++) { if ($changedLines === true) { // Changed lines. break; } if (isset($this->knownLengths[$this->tokens[$next]['code']]) === false && strpos($this->tokens[$next]['content'], $this->eolChar) !== false ) { // Last token on the current line. $changedLines = true; } if ($next === $i) { continue; } if ($this->tokens[$next]['code'] === T_WHITESPACE || ($this->tokens[$next]['code'] === T_INLINE_HTML && trim($this->tokens[$next]['content']) === '') ) { continue; } $lineHasOtherTokens = true; if ($this->tokens[$next]['code'] === T_CLOSE_TAG) { continue; } $lineHasOtherContent = true; break; }//end for }//end if if (substr($commentTextLower, 0, 9) === 'phpcs:set') { // Ignore standards for complete lines that change sniff settings. if ($lineHasOtherTokens === false) { $this->ignoredLines[$this->tokens[$i]['line']] = ['.all' => true]; } // Need to maintain case here, to get the correct sniff code. $parts = explode(' ', substr($commentText, 10)); if (count($parts) >= 2) { $sniffParts = explode('.', $parts[0]); if (count($sniffParts) >= 3) { $this->tokens[$i]['sniffCode'] = array_shift($parts); $this->tokens[$i]['sniffProperty'] = array_shift($parts); $this->tokens[$i]['sniffPropertyValue'] = rtrim(implode(' ', $parts), " */\r\n"); } } $this->tokens[$i]['code'] = T_PHPCS_SET; $this->tokens[$i]['type'] = 'T_PHPCS_SET'; } else if (substr($commentTextLower, 0, 16) === 'phpcs:ignorefile') { // The whole file will be ignored, but at least set the correct token. $this->tokens[$i]['code'] = T_PHPCS_IGNORE_FILE; $this->tokens[$i]['type'] = 'T_PHPCS_IGNORE_FILE'; } else if (substr($commentTextLower, 0, 13) === 'phpcs:disable') { if ($lineHasOtherContent === false) { // Completely ignore the comment line. $this->ignoredLines[$this->tokens[$i]['line']] = ['.all' => true]; } if ($ignoring === null) { $ignoring = []; } $disabledSniffs = []; $additionalText = substr($commentText, 14); if ($additionalText === false) { $ignoring = ['.all' => true]; } else { $parts = explode(',', substr($commentText, 13)); foreach ($parts as $sniffCode) { $sniffCode = trim($sniffCode); $disabledSniffs[$sniffCode] = true; $ignoring[$sniffCode] = true; // This newly disabled sniff might be disabling an existing // enabled exception that we are tracking. if (isset($ignoring['.except']) === true) { foreach (array_keys($ignoring['.except']) as $ignoredSniffCode) { if ($ignoredSniffCode === $sniffCode || strpos($ignoredSniffCode, $sniffCode.'.') === 0 ) { unset($ignoring['.except'][$ignoredSniffCode]); } } if (empty($ignoring['.except']) === true) { unset($ignoring['.except']); } } }//end foreach }//end if $this->tokens[$i]['code'] = T_PHPCS_DISABLE; $this->tokens[$i]['type'] = 'T_PHPCS_DISABLE'; $this->tokens[$i]['sniffCodes'] = $disabledSniffs; } else if (substr($commentTextLower, 0, 12) === 'phpcs:enable') { if ($ignoring !== null) { $enabledSniffs = []; $additionalText = substr($commentText, 13); if ($additionalText === false) { $ignoring = null; } else { $parts = explode(',', substr($commentText, 13)); foreach ($parts as $sniffCode) { $sniffCode = trim($sniffCode); $enabledSniffs[$sniffCode] = true; // This new enabled sniff might remove previously disabled // sniffs if it is actually a standard or category of sniffs. foreach (array_keys($ignoring) as $ignoredSniffCode) { if ($ignoredSniffCode === $sniffCode || strpos($ignoredSniffCode, $sniffCode.'.') === 0 ) { unset($ignoring[$ignoredSniffCode]); } } // This new enabled sniff might be able to clear up // previously enabled sniffs if it is actually a standard or // category of sniffs. if (isset($ignoring['.except']) === true) { foreach (array_keys($ignoring['.except']) as $ignoredSniffCode) { if ($ignoredSniffCode === $sniffCode || strpos($ignoredSniffCode, $sniffCode.'.') === 0 ) { unset($ignoring['.except'][$ignoredSniffCode]); } } } }//end foreach if (empty($ignoring) === true) { $ignoring = null; } else { if (isset($ignoring['.except']) === true) { $ignoring['.except'] += $enabledSniffs; } else { $ignoring['.except'] = $enabledSniffs; } } }//end if if ($lineHasOtherContent === false) { // Completely ignore the comment line. $this->ignoredLines[$this->tokens[$i]['line']] = ['.all' => true]; } else { // The comment is on the same line as the code it is ignoring, // so respect the new ignore rules. $this->ignoredLines[$this->tokens[$i]['line']] = $ignoring; } $this->tokens[$i]['sniffCodes'] = $enabledSniffs; }//end if $this->tokens[$i]['code'] = T_PHPCS_ENABLE; $this->tokens[$i]['type'] = 'T_PHPCS_ENABLE'; } else if (substr($commentTextLower, 0, 12) === 'phpcs:ignore') { $ignoreRules = []; $additionalText = substr($commentText, 13); if ($additionalText === false) { $ignoreRules = ['.all' => true]; } else { $parts = explode(',', substr($commentText, 13)); foreach ($parts as $sniffCode) { $ignoreRules[trim($sniffCode)] = true; } } $this->tokens[$i]['code'] = T_PHPCS_IGNORE; $this->tokens[$i]['type'] = 'T_PHPCS_IGNORE'; $this->tokens[$i]['sniffCodes'] = $ignoreRules; if ($ignoring !== null) { $ignoreRules += $ignoring; } if ($lineHasOtherContent === false) { // Completely ignore the comment line, and set the following // line to include the ignore rules we've set. $this->ignoredLines[$this->tokens[$i]['line']] = ['.all' => true]; $this->ignoredLines[($this->tokens[$i]['line'] + 1)] = $ignoreRules; } else { // The comment is on the same line as the code it is ignoring, // so respect the ignore rules it set. $this->ignoredLines[$this->tokens[$i]['line']] = $ignoreRules; } }//end if }//end if }//end if if ($ignoring !== null && isset($this->ignoredLines[$this->tokens[$i]['line']]) === false) { $this->ignoredLines[$this->tokens[$i]['line']] = $ignoring; } }//end for // If annotations are being ignored, we clear out all the ignore rules // but leave the annotations tokenized as normal. if ($checkAnnotations === false) { $this->ignoredLines = []; } }//end createPositionMap() /** * Replaces tabs in original token content with spaces. * * Each tab can represent between 1 and $config->tabWidth spaces, * so this cannot be a straight string replace. The original content * is placed into an orig_content index and the new token length is also * set in the length index. * * @param array $token The token to replace tabs inside. * @param string $prefix The character to use to represent the start of a tab. * @param string $padding The character to use to represent the end of a tab. * @param int $tabWidth The number of spaces each tab represents. * * @return void */ public function replaceTabsInToken(&$token, $prefix=' ', $padding=' ', $tabWidth=null) { $checkEncoding = false; if (function_exists('iconv_strlen') === true) { $checkEncoding = true; } $currColumn = $token['column']; if ($tabWidth === null) { $tabWidth = $this->config->tabWidth; if ($tabWidth === 0) { $tabWidth = 1; } } if (rtrim($token['content'], "\t") === '') { // String only contains tabs, so we can shortcut the process. $numTabs = strlen($token['content']); $firstTabSize = ($tabWidth - (($currColumn - 1) % $tabWidth)); $length = ($firstTabSize + ($tabWidth * ($numTabs - 1))); $newContent = $prefix.str_repeat($padding, ($length - 1)); } else { // We need to determine the length of each tab. $tabs = explode("\t", $token['content']); $numTabs = (count($tabs) - 1); $tabNum = 0; $newContent = ''; $length = 0; foreach ($tabs as $content) { if ($content !== '') { $newContent .= $content; if ($checkEncoding === true) { // Not using the default encoding, so take a bit more care. $oldLevel = error_reporting(); error_reporting(0); $contentLength = iconv_strlen($content, $this->config->encoding); error_reporting($oldLevel); if ($contentLength === false) { // String contained invalid characters, so revert to default. $contentLength = strlen($content); } } else { $contentLength = strlen($content); } $currColumn += $contentLength; $length += $contentLength; } // The last piece of content does not have a tab after it. if ($tabNum === $numTabs) { break; } // Process the tab that comes after the content. $lastCurrColumn = $currColumn; $tabNum++; // Move the pointer to the next tab stop. if (($currColumn % $tabWidth) === 0) { // This is the first tab, and we are already at a // tab stop, so this tab counts as a single space. $currColumn++; } else { $currColumn++; while (($currColumn % $tabWidth) !== 0) { $currColumn++; } $currColumn++; } $length += ($currColumn - $lastCurrColumn); $newContent .= $prefix.str_repeat($padding, ($currColumn - $lastCurrColumn - 1)); }//end foreach }//end if $token['orig_content'] = $token['content']; $token['content'] = $newContent; $token['length'] = $length; }//end replaceTabsInToken() /** * Creates a map of brackets positions. * * @return void */ private function createTokenMap() { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t*** START TOKEN MAP ***".PHP_EOL; } $squareOpeners = []; $curlyOpeners = []; $this->numTokens = count($this->tokens); $openers = []; $openOwner = null; for ($i = 0; $i < $this->numTokens; $i++) { /* Parenthesis mapping. */ if (isset(Util\Tokens::$parenthesisOpeners[$this->tokens[$i]['code']]) === true) { $this->tokens[$i]['parenthesis_opener'] = null; $this->tokens[$i]['parenthesis_closer'] = null; $this->tokens[$i]['parenthesis_owner'] = $i; $openOwner = $i; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", (count($openers) + 1)); echo "=> Found parenthesis owner at $i".PHP_EOL; } } else if ($this->tokens[$i]['code'] === T_OPEN_PARENTHESIS) { $openers[] = $i; $this->tokens[$i]['parenthesis_opener'] = $i; if ($openOwner !== null) { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", count($openers)); echo "=> Found parenthesis opener at $i for $openOwner".PHP_EOL; } $this->tokens[$openOwner]['parenthesis_opener'] = $i; $this->tokens[$i]['parenthesis_owner'] = $openOwner; $openOwner = null; } else if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", count($openers)); echo "=> Found unowned parenthesis opener at $i".PHP_EOL; } } else if ($this->tokens[$i]['code'] === T_CLOSE_PARENTHESIS) { // Did we set an owner for this set of parenthesis? $numOpeners = count($openers); if ($numOpeners !== 0) { $opener = array_pop($openers); if (isset($this->tokens[$opener]['parenthesis_owner']) === true) { $owner = $this->tokens[$opener]['parenthesis_owner']; $this->tokens[$owner]['parenthesis_closer'] = $i; $this->tokens[$i]['parenthesis_owner'] = $owner; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", (count($openers) + 1)); echo "=> Found parenthesis closer at $i for $owner".PHP_EOL; } } else if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", (count($openers) + 1)); echo "=> Found unowned parenthesis closer at $i for $opener".PHP_EOL; } $this->tokens[$i]['parenthesis_opener'] = $opener; $this->tokens[$i]['parenthesis_closer'] = $i; $this->tokens[$opener]['parenthesis_closer'] = $i; }//end if }//end if /* Bracket mapping. */ switch ($this->tokens[$i]['code']) { case T_OPEN_SQUARE_BRACKET: $squareOpeners[] = $i; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", count($squareOpeners)); echo str_repeat("\t", count($curlyOpeners)); echo "=> Found square bracket opener at $i".PHP_EOL; } break; case T_OPEN_CURLY_BRACKET: if (isset($this->tokens[$i]['scope_closer']) === false) { $curlyOpeners[] = $i; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", count($squareOpeners)); echo str_repeat("\t", count($curlyOpeners)); echo "=> Found curly bracket opener at $i".PHP_EOL; } } break; case T_CLOSE_SQUARE_BRACKET: if (empty($squareOpeners) === false) { $opener = array_pop($squareOpeners); $this->tokens[$i]['bracket_opener'] = $opener; $this->tokens[$i]['bracket_closer'] = $i; $this->tokens[$opener]['bracket_opener'] = $opener; $this->tokens[$opener]['bracket_closer'] = $i; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", count($squareOpeners)); echo str_repeat("\t", count($curlyOpeners)); echo "\t=> Found square bracket closer at $i for $opener".PHP_EOL; } } break; case T_CLOSE_CURLY_BRACKET: if (empty($curlyOpeners) === false && isset($this->tokens[$i]['scope_opener']) === false ) { $opener = array_pop($curlyOpeners); $this->tokens[$i]['bracket_opener'] = $opener; $this->tokens[$i]['bracket_closer'] = $i; $this->tokens[$opener]['bracket_opener'] = $opener; $this->tokens[$opener]['bracket_closer'] = $i; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", count($squareOpeners)); echo str_repeat("\t", count($curlyOpeners)); echo "\t=> Found curly bracket closer at $i for $opener".PHP_EOL; } } break; default: continue 2; }//end switch }//end for // Cleanup for any openers that we didn't find closers for. // This typically means there was a syntax error breaking things. foreach ($openers as $opener) { unset($this->tokens[$opener]['parenthesis_opener']); unset($this->tokens[$opener]['parenthesis_owner']); } if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t*** END TOKEN MAP ***".PHP_EOL; } }//end createTokenMap() /** * Creates a map for the parenthesis tokens that surround other tokens. * * @return void */ private function createParenthesisNestingMap() { $map = []; for ($i = 0; $i < $this->numTokens; $i++) { if (isset($this->tokens[$i]['parenthesis_opener']) === true && $i === $this->tokens[$i]['parenthesis_opener'] ) { if (empty($map) === false) { $this->tokens[$i]['nested_parenthesis'] = $map; } if (isset($this->tokens[$i]['parenthesis_closer']) === true) { $map[$this->tokens[$i]['parenthesis_opener']] = $this->tokens[$i]['parenthesis_closer']; } } else if (isset($this->tokens[$i]['parenthesis_closer']) === true && $i === $this->tokens[$i]['parenthesis_closer'] ) { array_pop($map); if (empty($map) === false) { $this->tokens[$i]['nested_parenthesis'] = $map; } } else { if (empty($map) === false) { $this->tokens[$i]['nested_parenthesis'] = $map; } }//end if }//end for }//end createParenthesisNestingMap() /** * Creates a scope map of tokens that open scopes. * * @return void * @see recurseScopeMap() */ private function createScopeMap() { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t*** START SCOPE MAP ***".PHP_EOL; } for ($i = 0; $i < $this->numTokens; $i++) { // Check to see if the current token starts a new scope. if (isset($this->scopeOpeners[$this->tokens[$i]['code']]) === true) { if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$i]['type']; $content = Util\Common::prepareForOutput($this->tokens[$i]['content']); echo "\tStart scope map at $i:$type => $content".PHP_EOL; } if (isset($this->tokens[$i]['scope_condition']) === true) { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t* already processed, skipping *".PHP_EOL; } continue; } $i = $this->recurseScopeMap($i); }//end if }//end for if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t*** END SCOPE MAP ***".PHP_EOL; } }//end createScopeMap() /** * Recurses though the scope openers to build a scope map. * * @param int $stackPtr The position in the stack of the token that * opened the scope (eg. an IF token or FOR token). * @param int $depth How many scope levels down we are. * @param int $ignore How many curly braces we are ignoring. * * @return int The position in the stack that closed the scope. * @throws \PHP_CodeSniffer\Exceptions\TokenizerException If the nesting level gets too deep. */ private function recurseScopeMap($stackPtr, $depth=1, &$ignore=0) { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "=> Begin scope map recursion at token $stackPtr with depth $depth".PHP_EOL; } $opener = null; $currType = $this->tokens[$stackPtr]['code']; $startLine = $this->tokens[$stackPtr]['line']; // We will need this to restore the value if we end up // returning a token ID that causes our calling function to go back // over already ignored braces. $originalIgnore = $ignore; // If the start token for this scope opener is the same as // the scope token, we have already found our opener. if (isset($this->scopeOpeners[$currType]['start'][$currType]) === true) { $opener = $stackPtr; } for ($i = ($stackPtr + 1); $i < $this->numTokens; $i++) { $tokenType = $this->tokens[$i]['code']; if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$i]['type']; $line = $this->tokens[$i]['line']; $content = Util\Common::prepareForOutput($this->tokens[$i]['content']); echo str_repeat("\t", $depth); echo "Process token $i on line $line ["; if ($opener !== null) { echo "opener:$opener;"; } if ($ignore > 0) { echo "ignore=$ignore;"; } echo "]: $type => $content".PHP_EOL; }//end if // Very special case for IF statements in PHP that can be defined without // scope tokens. E.g., if (1) 1; 1 ? (1 ? 1 : 1) : 1; // If an IF statement below this one has an opener but no // keyword, the opener will be incorrectly assigned to this IF statement. // The same case also applies to USE statements, which don't have to have // openers, so a following USE statement can cause an incorrect brace match. if (($currType === T_IF || $currType === T_ELSE || $currType === T_USE) && $opener === null && ($this->tokens[$i]['code'] === T_SEMICOLON || $this->tokens[$i]['code'] === T_CLOSE_TAG) ) { if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$stackPtr]['type']; echo str_repeat("\t", $depth); if ($this->tokens[$i]['code'] === T_SEMICOLON) { $closerType = 'semicolon'; } else { $closerType = 'close tag'; } echo "=> Found $closerType before scope opener for $stackPtr:$type, bailing".PHP_EOL; } return $i; } // Special case for PHP control structures that have no braces. // If we find a curly brace closer before we find the opener, // we're not going to find an opener. That closer probably belongs to // a control structure higher up. if ($opener === null && $ignore === 0 && $tokenType === T_CLOSE_CURLY_BRACKET && isset($this->scopeOpeners[$currType]['end'][$tokenType]) === true ) { if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$stackPtr]['type']; echo str_repeat("\t", $depth); echo "=> Found curly brace closer before scope opener for $stackPtr:$type, bailing".PHP_EOL; } return ($i - 1); } if ($opener !== null && (isset($this->tokens[$i]['scope_opener']) === false || $this->scopeOpeners[$this->tokens[$stackPtr]['code']]['shared'] === true) && isset($this->scopeOpeners[$currType]['end'][$tokenType]) === true ) { if ($ignore > 0 && $tokenType === T_CLOSE_CURLY_BRACKET) { // The last opening bracket must have been for a string // offset or alike, so let's ignore it. if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo '* finished ignoring curly brace *'.PHP_EOL; } $ignore--; continue; } else if ($this->tokens[$opener]['code'] === T_OPEN_CURLY_BRACKET && $tokenType !== T_CLOSE_CURLY_BRACKET ) { // The opener is a curly bracket so the closer must be a curly bracket as well. // We ignore this closer to handle cases such as T_ELSE or T_ELSEIF being considered // a closer of T_IF when it should not. if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$stackPtr]['type']; echo str_repeat("\t", $depth); echo "=> Ignoring non-curly scope closer for $stackPtr:$type".PHP_EOL; } } else { $scopeCloser = $i; $todo = [ $stackPtr, $opener, ]; if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$stackPtr]['type']; $closerType = $this->tokens[$scopeCloser]['type']; echo str_repeat("\t", $depth); echo "=> Found scope closer ($scopeCloser:$closerType) for $stackPtr:$type".PHP_EOL; } $validCloser = true; if (($this->tokens[$stackPtr]['code'] === T_IF || $this->tokens[$stackPtr]['code'] === T_ELSEIF) && ($tokenType === T_ELSE || $tokenType === T_ELSEIF) ) { // To be a closer, this token must have an opener. if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "* closer needs to be tested *".PHP_EOL; } $i = self::recurseScopeMap($i, ($depth + 1), $ignore); if (isset($this->tokens[$scopeCloser]['scope_opener']) === false) { $validCloser = false; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "* closer is not valid (no opener found) *".PHP_EOL; } } else if ($this->tokens[$this->tokens[$scopeCloser]['scope_opener']]['code'] !== $this->tokens[$opener]['code']) { $validCloser = false; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); $type = $this->tokens[$this->tokens[$scopeCloser]['scope_opener']]['type']; $openerType = $this->tokens[$opener]['type']; echo "* closer is not valid (mismatched opener type; $type != $openerType) *".PHP_EOL; } } else if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "* closer was valid *".PHP_EOL; } } else { // The closer was not processed, so we need to // complete that token as well. $todo[] = $scopeCloser; }//end if if ($validCloser === true) { foreach ($todo as $token) { $this->tokens[$token]['scope_condition'] = $stackPtr; $this->tokens[$token]['scope_opener'] = $opener; $this->tokens[$token]['scope_closer'] = $scopeCloser; } if ($this->scopeOpeners[$this->tokens[$stackPtr]['code']]['shared'] === true) { // As we are going back to where we started originally, restore // the ignore value back to its original value. $ignore = $originalIgnore; return $opener; } else if ($scopeCloser === $i && isset($this->scopeOpeners[$tokenType]) === true ) { // Unset scope_condition here or else the token will appear to have // already been processed, and it will be skipped. Normally we want that, // but in this case, the token is both a closer and an opener, so // it needs to act like an opener. This is also why we return the // token before this one; so the closer has a chance to be processed // a second time, but as an opener. unset($this->tokens[$scopeCloser]['scope_condition']); return ($i - 1); } else { return $i; } } else { continue; }//end if }//end if }//end if // Is this an opening condition ? if (isset($this->scopeOpeners[$tokenType]) === true) { if ($opener === null) { if ($tokenType === T_USE) { // PHP use keywords are special because they can be // used as blocks but also inline in function definitions. // So if we find them nested inside another opener, just skip them. continue; } if ($tokenType === T_FUNCTION && $this->tokens[$stackPtr]['code'] !== T_FUNCTION ) { // Probably a closure, so process it manually. if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$stackPtr]['type']; echo str_repeat("\t", $depth); echo "=> Found function before scope opener for $stackPtr:$type, processing manually".PHP_EOL; } if (isset($this->tokens[$i]['scope_closer']) === true) { // We've already processed this closure. if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo '* already processed, skipping *'.PHP_EOL; } $i = $this->tokens[$i]['scope_closer']; continue; } $i = self::recurseScopeMap($i, ($depth + 1), $ignore); continue; }//end if if ($tokenType === T_CLASS) { // Probably an anonymous class inside another anonymous class, // so process it manually. if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$stackPtr]['type']; echo str_repeat("\t", $depth); echo "=> Found class before scope opener for $stackPtr:$type, processing manually".PHP_EOL; } if (isset($this->tokens[$i]['scope_closer']) === true) { // We've already processed this anon class. if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo '* already processed, skipping *'.PHP_EOL; } $i = $this->tokens[$i]['scope_closer']; continue; } $i = self::recurseScopeMap($i, ($depth + 1), $ignore); continue; }//end if // Found another opening condition but still haven't // found our opener, so we are never going to find one. if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$stackPtr]['type']; echo str_repeat("\t", $depth); echo "=> Found new opening condition before scope opener for $stackPtr:$type, "; } if (($this->tokens[$stackPtr]['code'] === T_IF || $this->tokens[$stackPtr]['code'] === T_ELSEIF || $this->tokens[$stackPtr]['code'] === T_ELSE) && ($this->tokens[$i]['code'] === T_ELSE || $this->tokens[$i]['code'] === T_ELSEIF) ) { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "continuing".PHP_EOL; } return ($i - 1); } else { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "backtracking".PHP_EOL; } return $stackPtr; } }//end if if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo '* token is an opening condition *'.PHP_EOL; } $isShared = ($this->scopeOpeners[$tokenType]['shared'] === true); if (isset($this->tokens[$i]['scope_condition']) === true) { // We've been here before. if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo '* already processed, skipping *'.PHP_EOL; } if ($isShared === false && isset($this->tokens[$i]['scope_closer']) === true ) { $i = $this->tokens[$i]['scope_closer']; } continue; } else if ($currType === $tokenType && $isShared === false && $opener === null ) { // We haven't yet found our opener, but we have found another // scope opener which is the same type as us, and we don't // share openers, so we will never find one. if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo '* it was another token\'s opener, bailing *'.PHP_EOL; } return $stackPtr; } else { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo '* searching for opener *'.PHP_EOL; } if (isset($this->scopeOpeners[$tokenType]['end'][T_CLOSE_CURLY_BRACKET]) === true) { $oldIgnore = $ignore; $ignore = 0; } // PHP has a max nesting level for functions. Stop before we hit that limit // because too many loops means we've run into trouble anyway. if ($depth > 50) { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo '* reached maximum nesting level; aborting *'.PHP_EOL; } throw new TokenizerException('Maximum nesting level reached; file could not be processed'); } $oldDepth = $depth; if ($isShared === true && isset($this->scopeOpeners[$tokenType]['with'][$currType]) === true ) { // Don't allow the depth to increment because this is // possibly not a true nesting if we are sharing our closer. // This can happen, for example, when a SWITCH has a large // number of CASE statements with the same shared BREAK. $depth--; } $i = self::recurseScopeMap($i, ($depth + 1), $ignore); $depth = $oldDepth; if (isset($this->scopeOpeners[$tokenType]['end'][T_CLOSE_CURLY_BRACKET]) === true) { $ignore = $oldIgnore; } }//end if }//end if if (isset($this->scopeOpeners[$currType]['start'][$tokenType]) === true && $opener === null ) { if ($tokenType === T_OPEN_CURLY_BRACKET) { if (isset($this->tokens[$stackPtr]['parenthesis_closer']) === true && $i < $this->tokens[$stackPtr]['parenthesis_closer'] ) { // We found a curly brace inside the condition of the // current scope opener, so it must be a string offset. if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo '* ignoring curly brace inside condition *'.PHP_EOL; } $ignore++; } else { // Make sure this is actually an opener and not a // string offset (e.g., $var{0}). for ($x = ($i - 1); $x > 0; $x--) { if (isset(Util\Tokens::$emptyTokens[$this->tokens[$x]['code']]) === true) { continue; } else { // If the first non-whitespace/comment token looks like this // brace is a string offset, or this brace is mid-way through // a new statement, it isn't a scope opener. $disallowed = Util\Tokens::$assignmentTokens; $disallowed += [ T_DOLLAR => true, T_VARIABLE => true, T_OBJECT_OPERATOR => true, T_COMMA => true, T_OPEN_PARENTHESIS => true, ]; if (isset($disallowed[$this->tokens[$x]['code']]) === true) { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo '* ignoring curly brace *'.PHP_EOL; } $ignore++; } break; }//end if }//end for }//end if }//end if if ($ignore === 0 || $tokenType !== T_OPEN_CURLY_BRACKET) { // We found the opening scope token for $currType. if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$stackPtr]['type']; echo str_repeat("\t", $depth); echo "=> Found scope opener for $stackPtr:$type".PHP_EOL; } $opener = $i; } } else if ($tokenType === T_SEMICOLON && $opener === null && (isset($this->tokens[$stackPtr]['parenthesis_closer']) === false || $i > $this->tokens[$stackPtr]['parenthesis_closer']) ) { // Found the end of a statement but still haven't // found our opener, so we are never going to find one. if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$stackPtr]['type']; echo str_repeat("\t", $depth); echo "=> Found end of statement before scope opener for $stackPtr:$type, continuing".PHP_EOL; } return ($i - 1); } else if ($tokenType === T_OPEN_PARENTHESIS) { if (isset($this->tokens[$i]['parenthesis_owner']) === true) { $owner = $this->tokens[$i]['parenthesis_owner']; if (isset(Util\Tokens::$scopeOpeners[$this->tokens[$owner]['code']]) === true && isset($this->tokens[$i]['parenthesis_closer']) === true ) { // If we get into here, then we opened a parenthesis for // a scope (eg. an if or else if) so we need to update the // start of the line so that when we check to see // if the closing parenthesis is more than n lines away from // the statement, we check from the closing parenthesis. $startLine = $this->tokens[$this->tokens[$i]['parenthesis_closer']]['line']; } } } else if ($tokenType === T_OPEN_CURLY_BRACKET && $opener !== null) { // We opened something that we don't have a scope opener for. // Examples of this are curly brackets for string offsets etc. // We want to ignore this so that we don't have an invalid scope // map. if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo '* ignoring curly brace *'.PHP_EOL; } $ignore++; } else if ($tokenType === T_CLOSE_CURLY_BRACKET && $ignore > 0) { // We found the end token for the opener we were ignoring. if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo '* finished ignoring curly brace *'.PHP_EOL; } $ignore--; } else if ($opener === null && isset($this->scopeOpeners[$currType]) === true ) { // If we still haven't found the opener after 30 lines, // we're not going to find it, unless we know it requires // an opener (in which case we better keep looking) or the last // token was empty (in which case we'll just confirm there is // more code in this file and not just a big comment). if ($this->tokens[$i]['line'] >= ($startLine + 30) && isset(Util\Tokens::$emptyTokens[$this->tokens[($i - 1)]['code']]) === false ) { if ($this->scopeOpeners[$currType]['strict'] === true) { if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$stackPtr]['type']; $lines = ($this->tokens[$i]['line'] - $startLine); echo str_repeat("\t", $depth); echo "=> Still looking for $stackPtr:$type scope opener after $lines lines".PHP_EOL; } } else { if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$stackPtr]['type']; echo str_repeat("\t", $depth); echo "=> Couldn't find scope opener for $stackPtr:$type, bailing".PHP_EOL; } return $stackPtr; } } } else if ($opener !== null && $tokenType !== T_BREAK && isset($this->endScopeTokens[$tokenType]) === true ) { if (isset($this->tokens[$i]['scope_condition']) === false) { if ($ignore > 0) { // We found the end token for the opener we were ignoring. if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo '* finished ignoring curly brace *'.PHP_EOL; } $ignore--; } else { // We found a token that closes the scope but it doesn't // have a condition, so it belongs to another token and // our token doesn't have a closer, so pretend this is // the closer. if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$stackPtr]['type']; echo str_repeat("\t", $depth); echo "=> Found (unexpected) scope closer for $stackPtr:$type".PHP_EOL; } foreach ([$stackPtr, $opener] as $token) { $this->tokens[$token]['scope_condition'] = $stackPtr; $this->tokens[$token]['scope_opener'] = $opener; $this->tokens[$token]['scope_closer'] = $i; } return ($i - 1); }//end if }//end if }//end if }//end for return $stackPtr; }//end recurseScopeMap() /** * Constructs the level map. * * The level map adds a 'level' index to each token which indicates the * depth that a token within a set of scope blocks. It also adds a * 'conditions' index which is an array of the scope conditions that opened * each of the scopes - position 0 being the first scope opener. * * @return void */ private function createLevelMap() { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t*** START LEVEL MAP ***".PHP_EOL; } $this->numTokens = count($this->tokens); $level = 0; $conditions = []; $lastOpener = null; $openers = []; for ($i = 0; $i < $this->numTokens; $i++) { if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$i]['type']; $line = $this->tokens[$i]['line']; $len = $this->tokens[$i]['length']; $col = $this->tokens[$i]['column']; $content = Util\Common::prepareForOutput($this->tokens[$i]['content']); echo str_repeat("\t", ($level + 1)); echo "Process token $i on line $line [col:$col;len:$len;lvl:$level;"; if (empty($conditions) !== true) { $conditionString = 'conds;'; foreach ($conditions as $condition) { $conditionString .= Util\Tokens::tokenName($condition).','; } echo rtrim($conditionString, ',').';'; } echo "]: $type => $content".PHP_EOL; }//end if $this->tokens[$i]['level'] = $level; $this->tokens[$i]['conditions'] = $conditions; if (isset($this->tokens[$i]['scope_condition']) === true) { // Check to see if this token opened the scope. if ($this->tokens[$i]['scope_opener'] === $i) { $stackPtr = $this->tokens[$i]['scope_condition']; if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$stackPtr]['type']; echo str_repeat("\t", ($level + 1)); echo "=> Found scope opener for $stackPtr:$type".PHP_EOL; } $stackPtr = $this->tokens[$i]['scope_condition']; // If we find a scope opener that has a shared closer, // then we need to go back over the condition map that we // just created and fix ourselves as we just added some // conditions where there was none. This happens for T_CASE // statements that are using the same break statement. if ($lastOpener !== null && $this->tokens[$lastOpener]['scope_closer'] === $this->tokens[$i]['scope_closer']) { // This opener shares its closer with the previous opener, // but we still need to check if the two openers share their // closer with each other directly (like CASE and DEFAULT) // or if they are just sharing because one doesn't have a // closer (like CASE with no BREAK using a SWITCHes closer). $thisType = $this->tokens[$this->tokens[$i]['scope_condition']]['code']; $opener = $this->tokens[$lastOpener]['scope_condition']; $isShared = isset($this->scopeOpeners[$thisType]['with'][$this->tokens[$opener]['code']]); reset($this->scopeOpeners[$thisType]['end']); reset($this->scopeOpeners[$this->tokens[$opener]['code']]['end']); $sameEnd = (current($this->scopeOpeners[$thisType]['end']) === current($this->scopeOpeners[$this->tokens[$opener]['code']]['end'])); if ($isShared === true && $sameEnd === true) { $badToken = $opener; if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$badToken]['type']; echo str_repeat("\t", ($level + 1)); echo "* shared closer, cleaning up $badToken:$type *".PHP_EOL; } for ($x = $this->tokens[$i]['scope_condition']; $x <= $i; $x++) { $oldConditions = $this->tokens[$x]['conditions']; $oldLevel = $this->tokens[$x]['level']; $this->tokens[$x]['level']--; unset($this->tokens[$x]['conditions'][$badToken]); if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$x]['type']; $oldConds = ''; foreach ($oldConditions as $condition) { $oldConds .= Util\Tokens::tokenName($condition).','; } $oldConds = rtrim($oldConds, ','); $newConds = ''; foreach ($this->tokens[$x]['conditions'] as $condition) { $newConds .= Util\Tokens::tokenName($condition).','; } $newConds = rtrim($newConds, ','); $newLevel = $this->tokens[$x]['level']; echo str_repeat("\t", ($level + 1)); echo "* cleaned $x:$type *".PHP_EOL; echo str_repeat("\t", ($level + 2)); echo "=> level changed from $oldLevel to $newLevel".PHP_EOL; echo str_repeat("\t", ($level + 2)); echo "=> conditions changed from $oldConds to $newConds".PHP_EOL; }//end if }//end for unset($conditions[$badToken]); if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$badToken]['type']; echo str_repeat("\t", ($level + 1)); echo "* token $badToken:$type removed from conditions array *".PHP_EOL; } unset($openers[$lastOpener]); $level--; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", ($level + 2)); echo '* level decreased *'.PHP_EOL; } }//end if }//end if $level++; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", ($level + 1)); echo '* level increased *'.PHP_EOL; } $conditions[$stackPtr] = $this->tokens[$stackPtr]['code']; if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$stackPtr]['type']; echo str_repeat("\t", ($level + 1)); echo "* token $stackPtr:$type added to conditions array *".PHP_EOL; } $lastOpener = $this->tokens[$i]['scope_opener']; if ($lastOpener !== null) { $openers[$lastOpener] = $lastOpener; } } else if ($lastOpener !== null && $this->tokens[$lastOpener]['scope_closer'] === $i) { foreach (array_reverse($openers) as $opener) { if ($this->tokens[$opener]['scope_closer'] === $i) { $oldOpener = array_pop($openers); if (empty($openers) === false) { $lastOpener = array_pop($openers); $openers[$lastOpener] = $lastOpener; } else { $lastOpener = null; } if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$oldOpener]['type']; echo str_repeat("\t", ($level + 1)); echo "=> Found scope closer for $oldOpener:$type".PHP_EOL; } $oldCondition = array_pop($conditions); if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", ($level + 1)); echo '* token '.Util\Tokens::tokenName($oldCondition).' removed from conditions array *'.PHP_EOL; } // Make sure this closer actually belongs to us. // Either the condition also has to think this is the // closer, or it has to allow sharing with us. $condition = $this->tokens[$this->tokens[$i]['scope_condition']]['code']; if ($condition !== $oldCondition) { if (isset($this->scopeOpeners[$oldCondition]['with'][$condition]) === false) { $badToken = $this->tokens[$oldOpener]['scope_condition']; if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = Util\Tokens::tokenName($oldCondition); echo str_repeat("\t", ($level + 1)); echo "* scope closer was bad, cleaning up $badToken:$type *".PHP_EOL; } for ($x = ($oldOpener + 1); $x <= $i; $x++) { $oldConditions = $this->tokens[$x]['conditions']; $oldLevel = $this->tokens[$x]['level']; $this->tokens[$x]['level']--; unset($this->tokens[$x]['conditions'][$badToken]); if (PHP_CODESNIFFER_VERBOSITY > 1) { $type = $this->tokens[$x]['type']; $oldConds = ''; foreach ($oldConditions as $condition) { $oldConds .= Util\Tokens::tokenName($condition).','; } $oldConds = rtrim($oldConds, ','); $newConds = ''; foreach ($this->tokens[$x]['conditions'] as $condition) { $newConds .= Util\Tokens::tokenName($condition).','; } $newConds = rtrim($newConds, ','); $newLevel = $this->tokens[$x]['level']; echo str_repeat("\t", ($level + 1)); echo "* cleaned $x:$type *".PHP_EOL; echo str_repeat("\t", ($level + 2)); echo "=> level changed from $oldLevel to $newLevel".PHP_EOL; echo str_repeat("\t", ($level + 2)); echo "=> conditions changed from $oldConds to $newConds".PHP_EOL; }//end if }//end for }//end if }//end if $level--; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", ($level + 2)); echo '* level decreased *'.PHP_EOL; } $this->tokens[$i]['level'] = $level; $this->tokens[$i]['conditions'] = $conditions; }//end if }//end foreach }//end if }//end if }//end for if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t*** END LEVEL MAP ***".PHP_EOL; } }//end createLevelMap() }//end class PHP_CodeSniffer-3.5.4/src/Util/Cache.php0000644000076500000240000002537613614652362017552 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Util; use PHP_CodeSniffer\Autoload; use PHP_CodeSniffer\Config; use PHP_CodeSniffer\Ruleset; class Cache { /** * The filesystem location of the cache file. * * @var void */ private static $path = ''; /** * The cached data. * * @var array */ private static $cache = []; /** * Loads existing cache data for the run, if any. * * @param \PHP_CodeSniffer\Ruleset $ruleset The ruleset used for the run. * @param \PHP_CodeSniffer\Config $config The config data for the run. * * @return void */ public static function load(Ruleset $ruleset, Config $config) { // Look at every loaded sniff class so far and use their file contents // to generate a hash for the code used during the run. // At this point, the loaded class list contains the core PHPCS code // and all sniffs that have been loaded as part of the run. if (PHP_CODESNIFFER_VERBOSITY > 1) { echo PHP_EOL."\tGenerating loaded file list for code hash".PHP_EOL; } $codeHashFiles = []; $classes = array_keys(Autoload::getLoadedClasses()); sort($classes); $installDir = dirname(__DIR__); $installDirLen = strlen($installDir); $standardDir = $installDir.DIRECTORY_SEPARATOR.'Standards'; $standardDirLen = strlen($standardDir); foreach ($classes as $file) { if (substr($file, 0, $standardDirLen) !== $standardDir) { if (substr($file, 0, $installDirLen) === $installDir) { // We are only interested in sniffs here. continue; } if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t=> external file: $file".PHP_EOL; } } else if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t=> internal sniff: $file".PHP_EOL; } $codeHashFiles[] = $file; } // Add the content of the used rulesets to the hash so that sniff setting // changes in the ruleset invalidate the cache. $rulesets = $ruleset->paths; sort($rulesets); foreach ($rulesets as $file) { if (substr($file, 0, $standardDirLen) !== $standardDir) { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t=> external ruleset: $file".PHP_EOL; } } else if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t=> internal ruleset: $file".PHP_EOL; } $codeHashFiles[] = $file; } // Go through the core PHPCS code and add those files to the file // hash. This ensures that core PHPCS changes will also invalidate the cache. // Note that we ignore sniffs here, and any files that don't affect // the outcome of the run. $di = new \RecursiveDirectoryIterator($installDir); $filter = new \RecursiveCallbackFilterIterator( $di, function ($file, $key, $iterator) { // Skip hidden files. $filename = $file->getFilename(); if (substr($filename, 0, 1) === '.') { return false; } $filePath = Common::realpath($file->getPathname()); if ($filePath === false) { return false; } if (is_dir($filePath) === true && ($filename === 'Standards' || $filename === 'Exceptions' || $filename === 'Reports' || $filename === 'Generators') ) { return false; } return true; } ); $iterator = new \RecursiveIteratorIterator($filter); foreach ($iterator as $file) { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t=> core file: $file".PHP_EOL; } $codeHashFiles[] = $file->getPathname(); } $codeHash = ''; sort($codeHashFiles); foreach ($codeHashFiles as $file) { $codeHash .= md5_file($file); } $codeHash = md5($codeHash); // Along with the code hash, use various settings that can affect // the results of a run to create a new hash. This hash will be used // in the cache file name. $rulesetHash = md5(var_export($ruleset->ignorePatterns, true).var_export($ruleset->includePatterns, true)); $configData = [ 'phpVersion' => PHP_VERSION_ID, 'tabWidth' => $config->tabWidth, 'encoding' => $config->encoding, 'recordErrors' => $config->recordErrors, 'annotations' => $config->annotations, 'configData' => Config::getAllConfigData(), 'codeHash' => $codeHash, 'rulesetHash' => $rulesetHash, ]; $configString = var_export($configData, true); $cacheHash = substr(sha1($configString), 0, 12); if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\tGenerating cache key data".PHP_EOL; foreach ($configData as $key => $value) { if (is_array($value) === true) { echo "\t\t=> $key:".PHP_EOL; foreach ($value as $subKey => $subValue) { echo "\t\t\t=> $subKey: $subValue".PHP_EOL; } continue; } if ($value === true || $value === false) { $value = (int) $value; } echo "\t\t=> $key: $value".PHP_EOL; } echo "\t\t=> cacheHash: $cacheHash".PHP_EOL; }//end if if ($config->cacheFile !== null) { $cacheFile = $config->cacheFile; } else { // Determine the common paths for all files being checked. // We can use this to locate an existing cache file, or to // determine where to create a new one. if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\tChecking possible cache file paths".PHP_EOL; } $paths = []; foreach ($config->files as $file) { $file = Common::realpath($file); while ($file !== DIRECTORY_SEPARATOR) { if (isset($paths[$file]) === false) { $paths[$file] = 1; } else { $paths[$file]++; } $lastFile = $file; $file = dirname($file); if ($file === $lastFile) { // Just in case something went wrong, // we don't want to end up in an infinite loop. break; } } } ksort($paths); $paths = array_reverse($paths); $numFiles = count($config->files); $cacheFile = null; $cacheDir = getenv('XDG_CACHE_HOME'); if ($cacheDir === false || is_dir($cacheDir) === false) { $cacheDir = sys_get_temp_dir(); } foreach ($paths as $file => $count) { if ($count !== $numFiles) { unset($paths[$file]); continue; } $fileHash = substr(sha1($file), 0, 12); $testFile = $cacheDir.DIRECTORY_SEPARATOR."phpcs.$fileHash.$cacheHash.cache"; if ($cacheFile === null) { // This will be our default location if we can't find // an existing file. $cacheFile = $testFile; } if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t\t=> $testFile".PHP_EOL; echo "\t\t\t * based on shared location: $file *".PHP_EOL; } if (file_exists($testFile) === true) { $cacheFile = $testFile; break; } }//end foreach if ($cacheFile === null) { // Unlikely, but just in case $paths is empty for some reason. $cacheFile = $cacheDir.DIRECTORY_SEPARATOR."phpcs.$cacheHash.cache"; } }//end if self::$path = $cacheFile; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t=> Using cache file: ".self::$path.PHP_EOL; } if (file_exists(self::$path) === true) { self::$cache = json_decode(file_get_contents(self::$path), true); // Verify the contents of the cache file. if (self::$cache['config'] !== $configData) { self::$cache = []; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t* cache was invalid and has been cleared *".PHP_EOL; } } } else if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t* cache file does not exist *".PHP_EOL; } self::$cache['config'] = $configData; }//end load() /** * Saves the current cache to the filesystem. * * @return void */ public static function save() { file_put_contents(self::$path, json_encode(self::$cache)); }//end save() /** * Retrieves a single entry from the cache. * * @param string $key The key of the data to get. If NULL, * everything in the cache is returned. * * @return mixed */ public static function get($key=null) { if ($key === null) { return self::$cache; } if (isset(self::$cache[$key]) === true) { return self::$cache[$key]; } return false; }//end get() /** * Retrieves a single entry from the cache. * * @param string $key The key of the data to set. If NULL, * sets the entire cache. * @param mixed $value The value to set. * * @return void */ public static function set($key, $value) { if ($key === null) { self::$cache = $value; } else { self::$cache[$key] = $value; } }//end set() /** * Retrieves the number of cache entries. * * @return int */ public static function getSize() { return (count(self::$cache) - 1); }//end getSize() }//end class PHP_CodeSniffer-3.5.4/src/Util/Common.php0000644000076500000240000003542113614652362017767 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Util; class Common { /** * An array of variable types for param/var we will check. * * @var string[] */ public static $allowedTypes = [ 'array', 'boolean', 'float', 'integer', 'mixed', 'object', 'string', 'resource', 'callable', ]; /** * Return TRUE if the path is a PHAR file. * * @param string $path The path to use. * * @return mixed */ public static function isPharFile($path) { if (strpos($path, 'phar://') === 0) { return true; } return false; }//end isPharFile() /** * CodeSniffer alternative for realpath. * * Allows for PHAR support. * * @param string $path The path to use. * * @return mixed */ public static function realpath($path) { // Support the path replacement of ~ with the user's home directory. if (substr($path, 0, 2) === '~/') { $homeDir = getenv('HOME'); if ($homeDir !== false) { $path = $homeDir.substr($path, 1); } } // Check for process substitution. if (strpos($path, '/dev/fd') === 0) { return str_replace('/dev/fd', 'php://fd', $path); } // No extra work needed if this is not a phar file. if (self::isPharFile($path) === false) { return realpath($path); } // Before trying to break down the file path, // check if it exists first because it will mostly not // change after running the below code. if (file_exists($path) === true) { return $path; } $phar = \Phar::running(false); $extra = str_replace('phar://'.$phar, '', $path); $path = realpath($phar); if ($path === false) { return false; } $path = 'phar://'.$path.$extra; if (file_exists($path) === true) { return $path; } return false; }//end realpath() /** * Removes a base path from the front of a file path. * * @param string $path The path of the file. * @param string $basepath The base path to remove. This should not end * with a directory separator. * * @return string */ public static function stripBasepath($path, $basepath) { if (empty($basepath) === true) { return $path; } $basepathLen = strlen($basepath); if (substr($path, 0, $basepathLen) === $basepath) { $path = substr($path, $basepathLen); } $path = ltrim($path, DIRECTORY_SEPARATOR); if ($path === '') { $path = '.'; } return $path; }//end stripBasepath() /** * Detects the EOL character being used in a string. * * @param string $contents The contents to check. * * @return string */ public static function detectLineEndings($contents) { if (preg_match("/\r\n?|\n/", $contents, $matches) !== 1) { // Assume there are no newlines. $eolChar = "\n"; } else { $eolChar = $matches[0]; } return $eolChar; }//end detectLineEndings() /** * Check if STDIN is a TTY. * * @return boolean */ public static function isStdinATTY() { // The check is slow (especially calling `tty`) so we static // cache the result. static $isTTY = null; if ($isTTY !== null) { return $isTTY; } if (defined('STDIN') === false) { return false; } // If PHP has the POSIX extensions we will use them. if (function_exists('posix_isatty') === true) { $isTTY = (posix_isatty(STDIN) === true); return $isTTY; } // Next try is detecting whether we have `tty` installed and use that. if (defined('PHP_WINDOWS_VERSION_PLATFORM') === true) { $devnull = 'NUL'; $which = 'where'; } else { $devnull = '/dev/null'; $which = 'which'; } $tty = trim(shell_exec("$which tty 2> $devnull")); if (empty($tty) === false) { exec("tty -s 2> $devnull", $output, $returnValue); $isTTY = ($returnValue === 0); return $isTTY; } // Finally we will use fstat. The solution borrowed from // https://stackoverflow.com/questions/11327367/detect-if-a-php-script-is-being-run-interactively-or-not // This doesn't work on Mingw/Cygwin/... using Mintty but they // have `tty` installed. $type = [ 'S_IFMT' => 0170000, 'S_IFIFO' => 0010000, ]; $stat = fstat(STDIN); $mode = ($stat['mode'] & $type['S_IFMT']); $isTTY = ($mode !== $type['S_IFIFO']); return $isTTY; }//end isStdinATTY() /** * Prepares token content for output to screen. * * Replaces invisible characters so they are visible. On non-Windows * operating systems it will also colour the invisible characters. * * @param string $content The content to prepare. * @param string[] $exclude A list of characters to leave invisible. * Can contain \r, \n, \t and a space. * * @return string */ public static function prepareForOutput($content, $exclude=[]) { if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') { if (in_array("\r", $exclude, true) === false) { $content = str_replace("\r", '\r', $content); } if (in_array("\n", $exclude, true) === false) { $content = str_replace("\n", '\n', $content); } if (in_array("\t", $exclude, true) === false) { $content = str_replace("\t", '\t', $content); } } else { if (in_array("\r", $exclude, true) === false) { $content = str_replace("\r", "\033[30;1m\\r\033[0m", $content); } if (in_array("\n", $exclude, true) === false) { $content = str_replace("\n", "\033[30;1m\\n\033[0m", $content); } if (in_array("\t", $exclude, true) === false) { $content = str_replace("\t", "\033[30;1m\\t\033[0m", $content); } if (in_array(' ', $exclude, true) === false) { $content = str_replace(' ', "\033[30;1m·\033[0m", $content); } }//end if return $content; }//end prepareForOutput() /** * Returns true if the specified string is in the camel caps format. * * @param string $string The string the verify. * @param boolean $classFormat If true, check to see if the string is in the * class format. Class format strings must start * with a capital letter and contain no * underscores. * @param boolean $public If true, the first character in the string * must be an a-z character. If false, the * character must be an underscore. This * argument is only applicable if $classFormat * is false. * @param boolean $strict If true, the string must not have two capital * letters next to each other. If false, a * relaxed camel caps policy is used to allow * for acronyms. * * @return boolean */ public static function isCamelCaps( $string, $classFormat=false, $public=true, $strict=true ) { // Check the first character first. if ($classFormat === false) { $legalFirstChar = ''; if ($public === false) { $legalFirstChar = '[_]'; } if ($strict === false) { // Can either start with a lowercase letter, or multiple uppercase // in a row, representing an acronym. $legalFirstChar .= '([A-Z]{2,}|[a-z])'; } else { $legalFirstChar .= '[a-z]'; } } else { $legalFirstChar = '[A-Z]'; } if (preg_match("/^$legalFirstChar/", $string) === 0) { return false; } // Check that the name only contains legal characters. $legalChars = 'a-zA-Z0-9'; if (preg_match("|[^$legalChars]|", substr($string, 1)) > 0) { return false; } if ($strict === true) { // Check that there are not two capital letters next to each other. $length = strlen($string); $lastCharWasCaps = $classFormat; for ($i = 1; $i < $length; $i++) { $ascii = ord($string[$i]); if ($ascii >= 48 && $ascii <= 57) { // The character is a number, so it cant be a capital. $isCaps = false; } else { if (strtoupper($string[$i]) === $string[$i]) { $isCaps = true; } else { $isCaps = false; } } if ($isCaps === true && $lastCharWasCaps === true) { return false; } $lastCharWasCaps = $isCaps; } }//end if return true; }//end isCamelCaps() /** * Returns true if the specified string is in the underscore caps format. * * @param string $string The string to verify. * * @return boolean */ public static function isUnderscoreName($string) { // If there are space in the name, it can't be valid. if (strpos($string, ' ') !== false) { return false; } $validName = true; $nameBits = explode('_', $string); if (preg_match('|^[A-Z]|', $string) === 0) { // Name does not begin with a capital letter. $validName = false; } else { foreach ($nameBits as $bit) { if ($bit === '') { continue; } if ($bit[0] !== strtoupper($bit[0])) { $validName = false; break; } } } return $validName; }//end isUnderscoreName() /** * Returns a valid variable type for param/var tags. * * If type is not one of the standard types, it must be a custom type. * Returns the correct type name suggestion if type name is invalid. * * @param string $varType The variable type to process. * * @return string */ public static function suggestType($varType) { if ($varType === '') { return ''; } if (in_array($varType, self::$allowedTypes, true) === true) { return $varType; } else { $lowerVarType = strtolower($varType); switch ($lowerVarType) { case 'bool': case 'boolean': return 'boolean'; case 'double': case 'real': case 'float': return 'float'; case 'int': case 'integer': return 'integer'; case 'array()': case 'array': return 'array'; }//end switch if (strpos($lowerVarType, 'array(') !== false) { // Valid array declaration: // array, array(type), array(type1 => type2). $matches = []; $pattern = '/^array\(\s*([^\s^=^>]*)(\s*=>\s*(.*))?\s*\)/i'; if (preg_match($pattern, $varType, $matches) !== 0) { $type1 = ''; if (isset($matches[1]) === true) { $type1 = $matches[1]; } $type2 = ''; if (isset($matches[3]) === true) { $type2 = $matches[3]; } $type1 = self::suggestType($type1); $type2 = self::suggestType($type2); if ($type2 !== '') { $type2 = ' => '.$type2; } return "array($type1$type2)"; } else { return 'array'; }//end if } else if (in_array($lowerVarType, self::$allowedTypes, true) === true) { // A valid type, but not lower cased. return $lowerVarType; } else { // Must be a custom type name. return $varType; }//end if }//end if }//end suggestType() /** * Given a sniff class name, returns the code for the sniff. * * @param string $sniffClass The fully qualified sniff class name. * * @return string */ public static function getSniffCode($sniffClass) { $parts = explode('\\', $sniffClass); $sniff = array_pop($parts); if (substr($sniff, -5) === 'Sniff') { // Sniff class name. $sniff = substr($sniff, 0, -5); } else { // Unit test class name. $sniff = substr($sniff, 0, -8); } $category = array_pop($parts); $sniffDir = array_pop($parts); $standard = array_pop($parts); $code = $standard.'.'.$category.'.'.$sniff; return $code; }//end getSniffCode() /** * Removes project-specific information from a sniff class name. * * @param string $sniffClass The fully qualified sniff class name. * * @return string */ public static function cleanSniffClass($sniffClass) { $newName = strtolower($sniffClass); $sniffPos = strrpos($newName, '\sniffs\\'); if ($sniffPos === false) { // Nothing we can do as it isn't in a known format. return $newName; } $end = (strlen($newName) - $sniffPos + 1); $start = strrpos($newName, '\\', ($end * -1)); if ($start === false) { // Nothing needs to be cleaned. return $newName; } $newName = substr($newName, ($start + 1)); return $newName; }//end cleanSniffClass() }//end class PHP_CodeSniffer-3.5.4/src/Util/Standards.php0000644000076500000240000002557213614652362020470 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Util; use PHP_CodeSniffer\Config; class Standards { /** * Get a list of paths where standards are installed. * * Unresolvable relative paths will be excluded from the results. * * @return array */ public static function getInstalledStandardPaths() { $ds = DIRECTORY_SEPARATOR; $installedPaths = [dirname(dirname(__DIR__)).$ds.'src'.$ds.'Standards']; $configPaths = Config::getConfigData('installed_paths'); if ($configPaths !== null) { $installedPaths = array_merge($installedPaths, explode(',', $configPaths)); } $resolvedInstalledPaths = []; foreach ($installedPaths as $installedPath) { if (substr($installedPath, 0, 1) === '.') { $installedPath = Common::realPath(__DIR__.$ds.'..'.$ds.'..'.$ds.$installedPath); if ($installedPath === false) { continue; } } $resolvedInstalledPaths[] = $installedPath; } return $resolvedInstalledPaths; }//end getInstalledStandardPaths() /** * Get the details of all coding standards installed. * * Coding standards are directories located in the * CodeSniffer/Standards directory. Valid coding standards * include a Sniffs subdirectory. * * The details returned for each standard are: * - path: the path to the coding standard's main directory * - name: the name of the coding standard, as sourced from the ruleset.xml file * - namespace: the namespace used by the coding standard, as sourced from the ruleset.xml file * * If you only need the paths to the installed standards, * use getInstalledStandardPaths() instead as it performs less work to * retrieve coding standard names. * * @param boolean $includeGeneric If true, the special "Generic" * coding standard will be included * if installed. * @param string $standardsDir A specific directory to look for standards * in. If not specified, PHP_CodeSniffer will * look in its default locations. * * @return array * @see getInstalledStandardPaths() */ public static function getInstalledStandardDetails( $includeGeneric=false, $standardsDir='' ) { $rulesets = []; if ($standardsDir === '') { $installedPaths = self::getInstalledStandardPaths(); } else { $installedPaths = [$standardsDir]; } foreach ($installedPaths as $standardsDir) { // Check if the installed dir is actually a standard itself. $csFile = $standardsDir.'/ruleset.xml'; if (is_file($csFile) === true) { $rulesets[] = $csFile; continue; } if (is_dir($standardsDir) === false) { continue; } $di = new \DirectoryIterator($standardsDir); foreach ($di as $file) { if ($file->isDir() === true && $file->isDot() === false) { $filename = $file->getFilename(); // Ignore the special "Generic" standard. if ($includeGeneric === false && $filename === 'Generic') { continue; } // Valid coding standard dirs include a ruleset. $csFile = $file->getPathname().'/ruleset.xml'; if (is_file($csFile) === true) { $rulesets[] = $csFile; } } } }//end foreach $installedStandards = []; foreach ($rulesets as $rulesetPath) { $ruleset = @simplexml_load_string(file_get_contents($rulesetPath)); if ($ruleset === false) { continue; } $standardName = (string) $ruleset['name']; $dirname = basename(dirname($rulesetPath)); if (isset($ruleset['namespace']) === true) { $namespace = (string) $ruleset['namespace']; } else { $namespace = $dirname; } $installedStandards[$dirname] = [ 'path' => dirname($rulesetPath), 'name' => $standardName, 'namespace' => $namespace, ]; }//end foreach return $installedStandards; }//end getInstalledStandardDetails() /** * Get a list of all coding standards installed. * * Coding standards are directories located in the * CodeSniffer/Standards directory. Valid coding standards * include a Sniffs subdirectory. * * @param boolean $includeGeneric If true, the special "Generic" * coding standard will be included * if installed. * @param string $standardsDir A specific directory to look for standards * in. If not specified, PHP_CodeSniffer will * look in its default locations. * * @return array * @see isInstalledStandard() */ public static function getInstalledStandards( $includeGeneric=false, $standardsDir='' ) { $installedStandards = []; if ($standardsDir === '') { $installedPaths = self::getInstalledStandardPaths(); } else { $installedPaths = [$standardsDir]; } foreach ($installedPaths as $standardsDir) { // Check if the installed dir is actually a standard itself. $csFile = $standardsDir.'/ruleset.xml'; if (is_file($csFile) === true) { $installedStandards[] = basename($standardsDir); continue; } if (is_dir($standardsDir) === false) { // Doesn't exist. continue; } $di = new \DirectoryIterator($standardsDir); foreach ($di as $file) { if ($file->isDir() === true && $file->isDot() === false) { $filename = $file->getFilename(); // Ignore the special "Generic" standard. if ($includeGeneric === false && $filename === 'Generic') { continue; } // Valid coding standard dirs include a ruleset. $csFile = $file->getPathname().'/ruleset.xml'; if (is_file($csFile) === true) { $installedStandards[] = $filename; } } } }//end foreach return $installedStandards; }//end getInstalledStandards() /** * Determine if a standard is installed. * * Coding standards are directories located in the * CodeSniffer/Standards directory. Valid coding standards * include a ruleset.xml file. * * @param string $standard The name of the coding standard. * * @return boolean * @see getInstalledStandards() */ public static function isInstalledStandard($standard) { $path = self::getInstalledStandardPath($standard); if ($path !== null && strpos($path, 'ruleset.xml') !== false) { return true; } else { // This could be a custom standard, installed outside our // standards directory. $standard = Common::realPath($standard); if ($standard === false) { return false; } // Might be an actual ruleset file itUtil. // If it has an XML extension, let's at least try it. if (is_file($standard) === true && (substr(strtolower($standard), -4) === '.xml' || substr(strtolower($standard), -9) === '.xml.dist') ) { return true; } // If it is a directory with a ruleset.xml file in it, // it is a standard. $ruleset = rtrim($standard, ' /\\').DIRECTORY_SEPARATOR.'ruleset.xml'; if (is_file($ruleset) === true) { return true; } }//end if return false; }//end isInstalledStandard() /** * Return the path of an installed coding standard. * * Coding standards are directories located in the * CodeSniffer/Standards directory. Valid coding standards * include a ruleset.xml file. * * @param string $standard The name of the coding standard. * * @return string|null */ public static function getInstalledStandardPath($standard) { if (strpos($standard, '.') !== false) { return null; } $installedPaths = self::getInstalledStandardPaths(); foreach ($installedPaths as $installedPath) { $standardPath = $installedPath.DIRECTORY_SEPARATOR.$standard; if (file_exists($standardPath) === false) { if (basename($installedPath) !== $standard) { continue; } $standardPath = $installedPath; } $path = Common::realpath($standardPath.DIRECTORY_SEPARATOR.'ruleset.xml'); if ($path !== false && is_file($path) === true) { return $path; } else if (Common::isPharFile($standardPath) === true) { $path = Common::realpath($standardPath); if ($path !== false) { return $path; } } }//end foreach return null; }//end getInstalledStandardPath() /** * Prints out a list of installed coding standards. * * @return void */ public static function printInstalledStandards() { $installedStandards = self::getInstalledStandards(); $numStandards = count($installedStandards); if ($numStandards === 0) { echo 'No coding standards are installed.'.PHP_EOL; } else { $lastStandard = array_pop($installedStandards); if ($numStandards === 1) { echo "The only coding standard installed is $lastStandard".PHP_EOL; } else { $standardList = implode(', ', $installedStandards); $standardList .= ' and '.$lastStandard; echo 'The installed coding standards are '.$standardList.PHP_EOL; } } }//end printInstalledStandards() }//end class PHP_CodeSniffer-3.5.4/src/Util/Timing.php0000644000076500000240000000365013614652362017765 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Util; class Timing { /** * The start time of the run. * * @var float */ private static $startTime; /** * Used to make sure we only print the run time once per run. * * @var boolean */ private static $printed = false; /** * Start recording time for the run. * * @return void */ public static function startTiming() { self::$startTime = microtime(true); }//end startTiming() /** * Print information about the run. * * @param boolean $force If TRUE, prints the output even if it has * already been printed during the run. * * @return void */ public static function printRunTime($force=false) { if ($force === false && self::$printed === true) { // A double call. return; } if (self::$startTime === null) { // Timing was never started. return; } $time = ((microtime(true) - self::$startTime) * 1000); if ($time > 60000) { $mins = floor($time / 60000); $secs = round((($time % 60000) / 1000), 2); $time = $mins.' mins'; if ($secs !== 0) { $time .= ", $secs secs"; } } else if ($time > 1000) { $time = round(($time / 1000), 2).' secs'; } else { $time = round($time).'ms'; } $mem = round((memory_get_peak_usage(true) / (1024 * 1024)), 2).'MB'; echo "Time: $time; Memory: $mem".PHP_EOL.PHP_EOL; self::$printed = true; }//end printRunTime() }//end class PHP_CodeSniffer-3.5.4/src/Util/Tokens.php0000644000076500000240000005045013614652362020001 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer\Util; define('T_NONE', 'PHPCS_T_NONE'); define('T_OPEN_CURLY_BRACKET', 'PHPCS_T_OPEN_CURLY_BRACKET'); define('T_CLOSE_CURLY_BRACKET', 'PHPCS_T_CLOSE_CURLY_BRACKET'); define('T_OPEN_SQUARE_BRACKET', 'PHPCS_T_OPEN_SQUARE_BRACKET'); define('T_CLOSE_SQUARE_BRACKET', 'PHPCS_T_CLOSE_SQUARE_BRACKET'); define('T_OPEN_PARENTHESIS', 'PHPCS_T_OPEN_PARENTHESIS'); define('T_CLOSE_PARENTHESIS', 'PHPCS_T_CLOSE_PARENTHESIS'); define('T_COLON', 'PHPCS_T_COLON'); define('T_NULLABLE', 'PHPCS_T_NULLABLE'); define('T_STRING_CONCAT', 'PHPCS_T_STRING_CONCAT'); define('T_INLINE_THEN', 'PHPCS_T_INLINE_THEN'); define('T_INLINE_ELSE', 'PHPCS_T_INLINE_ELSE'); define('T_NULL', 'PHPCS_T_NULL'); define('T_FALSE', 'PHPCS_T_FALSE'); define('T_TRUE', 'PHPCS_T_TRUE'); define('T_SEMICOLON', 'PHPCS_T_SEMICOLON'); define('T_EQUAL', 'PHPCS_T_EQUAL'); define('T_MULTIPLY', 'PHPCS_T_MULTIPLY'); define('T_DIVIDE', 'PHPCS_T_DIVIDE'); define('T_PLUS', 'PHPCS_T_PLUS'); define('T_MINUS', 'PHPCS_T_MINUS'); define('T_MODULUS', 'PHPCS_T_MODULUS'); define('T_BITWISE_AND', 'PHPCS_T_BITWISE_AND'); define('T_BITWISE_OR', 'PHPCS_T_BITWISE_OR'); define('T_BITWISE_XOR', 'PHPCS_T_BITWISE_XOR'); define('T_BITWISE_NOT', 'PHPCS_T_BITWISE_NOT'); define('T_ARRAY_HINT', 'PHPCS_T_ARRAY_HINT'); define('T_GREATER_THAN', 'PHPCS_T_GREATER_THAN'); define('T_LESS_THAN', 'PHPCS_T_LESS_THAN'); define('T_BOOLEAN_NOT', 'PHPCS_T_BOOLEAN_NOT'); define('T_SELF', 'PHPCS_T_SELF'); define('T_PARENT', 'PHPCS_T_PARENT'); define('T_DOUBLE_QUOTED_STRING', 'PHPCS_T_DOUBLE_QUOTED_STRING'); define('T_COMMA', 'PHPCS_T_COMMA'); define('T_HEREDOC', 'PHPCS_T_HEREDOC'); define('T_PROTOTYPE', 'PHPCS_T_PROTOTYPE'); define('T_THIS', 'PHPCS_T_THIS'); define('T_REGULAR_EXPRESSION', 'PHPCS_T_REGULAR_EXPRESSION'); define('T_PROPERTY', 'PHPCS_T_PROPERTY'); define('T_LABEL', 'PHPCS_T_LABEL'); define('T_OBJECT', 'PHPCS_T_OBJECT'); define('T_CLOSE_OBJECT', 'PHPCS_T_CLOSE_OBJECT'); define('T_COLOUR', 'PHPCS_T_COLOUR'); define('T_HASH', 'PHPCS_T_HASH'); define('T_URL', 'PHPCS_T_URL'); define('T_STYLE', 'PHPCS_T_STYLE'); define('T_ASPERAND', 'PHPCS_T_ASPERAND'); define('T_DOLLAR', 'PHPCS_T_DOLLAR'); define('T_TYPEOF', 'PHPCS_T_TYPEOF'); define('T_CLOSURE', 'PHPCS_T_CLOSURE'); define('T_ANON_CLASS', 'PHPCS_T_ANON_CLASS'); define('T_BACKTICK', 'PHPCS_T_BACKTICK'); define('T_START_NOWDOC', 'PHPCS_T_START_NOWDOC'); define('T_NOWDOC', 'PHPCS_T_NOWDOC'); define('T_END_NOWDOC', 'PHPCS_T_END_NOWDOC'); define('T_OPEN_SHORT_ARRAY', 'PHPCS_T_OPEN_SHORT_ARRAY'); define('T_CLOSE_SHORT_ARRAY', 'PHPCS_T_CLOSE_SHORT_ARRAY'); define('T_GOTO_LABEL', 'PHPCS_T_GOTO_LABEL'); define('T_BINARY_CAST', 'PHPCS_T_BINARY_CAST'); define('T_EMBEDDED_PHP', 'PHPCS_T_EMBEDDED_PHP'); define('T_RETURN_TYPE', 'PHPCS_T_RETURN_TYPE'); define('T_OPEN_USE_GROUP', 'PHPCS_T_OPEN_USE_GROUP'); define('T_CLOSE_USE_GROUP', 'PHPCS_T_CLOSE_USE_GROUP'); define('T_ZSR', 'PHPCS_T_ZSR'); define('T_ZSR_EQUAL', 'PHPCS_T_ZSR_EQUAL'); define('T_FN_ARROW', 'T_FN_ARROW'); // Some PHP 5.5 tokens, replicated for lower versions. if (defined('T_FINALLY') === false) { define('T_FINALLY', 'PHPCS_T_FINALLY'); } if (defined('T_YIELD') === false) { define('T_YIELD', 'PHPCS_T_YIELD'); } // Some PHP 5.6 tokens, replicated for lower versions. if (defined('T_ELLIPSIS') === false) { define('T_ELLIPSIS', 'PHPCS_T_ELLIPSIS'); } if (defined('T_POW') === false) { define('T_POW', 'PHPCS_T_POW'); } if (defined('T_POW_EQUAL') === false) { define('T_POW_EQUAL', 'PHPCS_T_POW_EQUAL'); } // Some PHP 7 tokens, replicated for lower versions. if (defined('T_SPACESHIP') === false) { define('T_SPACESHIP', 'PHPCS_T_SPACESHIP'); } if (defined('T_COALESCE') === false) { define('T_COALESCE', 'PHPCS_T_COALESCE'); } if (defined('T_COALESCE_EQUAL') === false) { define('T_COALESCE_EQUAL', 'PHPCS_T_COALESCE_EQUAL'); } if (defined('T_YIELD_FROM') === false) { define('T_YIELD_FROM', 'PHPCS_T_YIELD_FROM'); } // Some PHP 7.4 tokens, replicated for lower versions. if (defined('T_BAD_CHARACTER') === false) { define('T_BAD_CHARACTER', 'PHPCS_T_BAD_CHARACTER'); } if (defined('T_FN') === false) { define('T_FN', 'PHPCS_T_FN'); } // Tokens used for parsing doc blocks. define('T_DOC_COMMENT_STAR', 'PHPCS_T_DOC_COMMENT_STAR'); define('T_DOC_COMMENT_WHITESPACE', 'PHPCS_T_DOC_COMMENT_WHITESPACE'); define('T_DOC_COMMENT_TAG', 'PHPCS_T_DOC_COMMENT_TAG'); define('T_DOC_COMMENT_OPEN_TAG', 'PHPCS_T_DOC_COMMENT_OPEN_TAG'); define('T_DOC_COMMENT_CLOSE_TAG', 'PHPCS_T_DOC_COMMENT_CLOSE_TAG'); define('T_DOC_COMMENT_STRING', 'PHPCS_T_DOC_COMMENT_STRING'); // Tokens used for PHPCS instruction comments. define('T_PHPCS_ENABLE', 'PHPCS_T_PHPCS_ENABLE'); define('T_PHPCS_DISABLE', 'PHPCS_T_PHPCS_DISABLE'); define('T_PHPCS_SET', 'PHPCS_T_PHPCS_SET'); define('T_PHPCS_IGNORE', 'PHPCS_T_PHPCS_IGNORE'); define('T_PHPCS_IGNORE_FILE', 'PHPCS_T_PHPCS_IGNORE_FILE'); final class Tokens { /** * The token weightings. * * @var array */ public static $weightings = [ T_CLASS => 1000, T_INTERFACE => 1000, T_TRAIT => 1000, T_NAMESPACE => 1000, T_FUNCTION => 100, T_CLOSURE => 100, /* * Conditions. */ T_WHILE => 50, T_FOR => 50, T_FOREACH => 50, T_IF => 50, T_ELSE => 50, T_ELSEIF => 50, T_DO => 50, T_TRY => 50, T_CATCH => 50, T_FINALLY => 50, T_SWITCH => 50, T_SELF => 25, T_PARENT => 25, /* * Operators and arithmetic. */ T_BITWISE_AND => 8, T_BITWISE_OR => 8, T_BITWISE_XOR => 8, T_MULTIPLY => 5, T_DIVIDE => 5, T_PLUS => 5, T_MINUS => 5, T_MODULUS => 5, T_POW => 5, T_SPACESHIP => 5, T_COALESCE => 5, T_COALESCE_EQUAL => 5, T_SL => 5, T_SR => 5, T_SL_EQUAL => 5, T_SR_EQUAL => 5, T_EQUAL => 5, T_AND_EQUAL => 5, T_CONCAT_EQUAL => 5, T_DIV_EQUAL => 5, T_MINUS_EQUAL => 5, T_MOD_EQUAL => 5, T_MUL_EQUAL => 5, T_OR_EQUAL => 5, T_PLUS_EQUAL => 5, T_XOR_EQUAL => 5, T_BOOLEAN_AND => 5, T_BOOLEAN_OR => 5, /* * Equality. */ T_IS_EQUAL => 5, T_IS_NOT_EQUAL => 5, T_IS_IDENTICAL => 5, T_IS_NOT_IDENTICAL => 5, T_IS_SMALLER_OR_EQUAL => 5, T_IS_GREATER_OR_EQUAL => 5, ]; /** * Tokens that represent assignments. * * @var array */ public static $assignmentTokens = [ T_EQUAL => T_EQUAL, T_AND_EQUAL => T_AND_EQUAL, T_OR_EQUAL => T_OR_EQUAL, T_CONCAT_EQUAL => T_CONCAT_EQUAL, T_DIV_EQUAL => T_DIV_EQUAL, T_MINUS_EQUAL => T_MINUS_EQUAL, T_POW_EQUAL => T_POW_EQUAL, T_MOD_EQUAL => T_MOD_EQUAL, T_MUL_EQUAL => T_MUL_EQUAL, T_PLUS_EQUAL => T_PLUS_EQUAL, T_XOR_EQUAL => T_XOR_EQUAL, T_DOUBLE_ARROW => T_DOUBLE_ARROW, T_SL_EQUAL => T_SL_EQUAL, T_SR_EQUAL => T_SR_EQUAL, T_COALESCE_EQUAL => T_COALESCE_EQUAL, T_ZSR_EQUAL => T_ZSR_EQUAL, ]; /** * Tokens that represent equality comparisons. * * @var array */ public static $equalityTokens = [ T_IS_EQUAL => T_IS_EQUAL, T_IS_NOT_EQUAL => T_IS_NOT_EQUAL, T_IS_IDENTICAL => T_IS_IDENTICAL, T_IS_NOT_IDENTICAL => T_IS_NOT_IDENTICAL, T_IS_SMALLER_OR_EQUAL => T_IS_SMALLER_OR_EQUAL, T_IS_GREATER_OR_EQUAL => T_IS_GREATER_OR_EQUAL, ]; /** * Tokens that represent comparison operator. * * @var array */ public static $comparisonTokens = [ T_IS_EQUAL => T_IS_EQUAL, T_IS_IDENTICAL => T_IS_IDENTICAL, T_IS_NOT_EQUAL => T_IS_NOT_EQUAL, T_IS_NOT_IDENTICAL => T_IS_NOT_IDENTICAL, T_LESS_THAN => T_LESS_THAN, T_GREATER_THAN => T_GREATER_THAN, T_IS_SMALLER_OR_EQUAL => T_IS_SMALLER_OR_EQUAL, T_IS_GREATER_OR_EQUAL => T_IS_GREATER_OR_EQUAL, T_SPACESHIP => T_SPACESHIP, T_COALESCE => T_COALESCE, ]; /** * Tokens that represent arithmetic operators. * * @var array */ public static $arithmeticTokens = [ T_PLUS => T_PLUS, T_MINUS => T_MINUS, T_MULTIPLY => T_MULTIPLY, T_DIVIDE => T_DIVIDE, T_MODULUS => T_MODULUS, T_POW => T_POW, ]; /** * Tokens that perform operations. * * @var array */ public static $operators = [ T_MINUS => T_MINUS, T_PLUS => T_PLUS, T_MULTIPLY => T_MULTIPLY, T_DIVIDE => T_DIVIDE, T_MODULUS => T_MODULUS, T_POW => T_POW, T_SPACESHIP => T_SPACESHIP, T_COALESCE => T_COALESCE, T_BITWISE_AND => T_BITWISE_AND, T_BITWISE_OR => T_BITWISE_OR, T_BITWISE_XOR => T_BITWISE_XOR, T_SL => T_SL, T_SR => T_SR, ]; /** * Tokens that perform boolean operations. * * @var array */ public static $booleanOperators = [ T_BOOLEAN_AND => T_BOOLEAN_AND, T_BOOLEAN_OR => T_BOOLEAN_OR, T_LOGICAL_AND => T_LOGICAL_AND, T_LOGICAL_OR => T_LOGICAL_OR, T_LOGICAL_XOR => T_LOGICAL_XOR, ]; /** * Tokens that represent casting. * * @var array */ public static $castTokens = [ T_INT_CAST => T_INT_CAST, T_STRING_CAST => T_STRING_CAST, T_DOUBLE_CAST => T_DOUBLE_CAST, T_ARRAY_CAST => T_ARRAY_CAST, T_BOOL_CAST => T_BOOL_CAST, T_OBJECT_CAST => T_OBJECT_CAST, T_UNSET_CAST => T_UNSET_CAST, T_BINARY_CAST => T_BINARY_CAST, ]; /** * Token types that open parenthesis. * * @var array */ public static $parenthesisOpeners = [ T_ARRAY => T_ARRAY, T_LIST => T_LIST, T_FUNCTION => T_FUNCTION, T_CLOSURE => T_CLOSURE, T_ANON_CLASS => T_ANON_CLASS, T_WHILE => T_WHILE, T_FOR => T_FOR, T_FOREACH => T_FOREACH, T_SWITCH => T_SWITCH, T_IF => T_IF, T_ELSEIF => T_ELSEIF, T_CATCH => T_CATCH, T_DECLARE => T_DECLARE, ]; /** * Tokens that are allowed to open scopes. * * @var array */ public static $scopeOpeners = [ T_CLASS => T_CLASS, T_ANON_CLASS => T_ANON_CLASS, T_INTERFACE => T_INTERFACE, T_TRAIT => T_TRAIT, T_NAMESPACE => T_NAMESPACE, T_FUNCTION => T_FUNCTION, T_CLOSURE => T_CLOSURE, T_IF => T_IF, T_SWITCH => T_SWITCH, T_CASE => T_CASE, T_DECLARE => T_DECLARE, T_DEFAULT => T_DEFAULT, T_WHILE => T_WHILE, T_ELSE => T_ELSE, T_ELSEIF => T_ELSEIF, T_FOR => T_FOR, T_FOREACH => T_FOREACH, T_DO => T_DO, T_TRY => T_TRY, T_CATCH => T_CATCH, T_FINALLY => T_FINALLY, T_PROPERTY => T_PROPERTY, T_OBJECT => T_OBJECT, T_USE => T_USE, ]; /** * Tokens that represent scope modifiers. * * @var array */ public static $scopeModifiers = [ T_PRIVATE => T_PRIVATE, T_PUBLIC => T_PUBLIC, T_PROTECTED => T_PROTECTED, ]; /** * Tokens that can prefix a method name * * @var array */ public static $methodPrefixes = [ T_PRIVATE => T_PRIVATE, T_PUBLIC => T_PUBLIC, T_PROTECTED => T_PROTECTED, T_ABSTRACT => T_ABSTRACT, T_STATIC => T_STATIC, T_FINAL => T_FINAL, ]; /** * Tokens that open code blocks. * * @var array */ public static $blockOpeners = [ T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET, T_OPEN_SQUARE_BRACKET => T_OPEN_SQUARE_BRACKET, T_OPEN_PARENTHESIS => T_OPEN_PARENTHESIS, T_OBJECT => T_OBJECT, ]; /** * Tokens that don't represent code. * * @var array */ public static $emptyTokens = [ T_WHITESPACE => T_WHITESPACE, T_COMMENT => T_COMMENT, T_DOC_COMMENT => T_DOC_COMMENT, T_DOC_COMMENT_STAR => T_DOC_COMMENT_STAR, T_DOC_COMMENT_WHITESPACE => T_DOC_COMMENT_WHITESPACE, T_DOC_COMMENT_TAG => T_DOC_COMMENT_TAG, T_DOC_COMMENT_OPEN_TAG => T_DOC_COMMENT_OPEN_TAG, T_DOC_COMMENT_CLOSE_TAG => T_DOC_COMMENT_CLOSE_TAG, T_DOC_COMMENT_STRING => T_DOC_COMMENT_STRING, T_PHPCS_ENABLE => T_PHPCS_ENABLE, T_PHPCS_DISABLE => T_PHPCS_DISABLE, T_PHPCS_SET => T_PHPCS_SET, T_PHPCS_IGNORE => T_PHPCS_IGNORE, T_PHPCS_IGNORE_FILE => T_PHPCS_IGNORE_FILE, ]; /** * Tokens that are comments. * * @var array */ public static $commentTokens = [ T_COMMENT => T_COMMENT, T_DOC_COMMENT => T_DOC_COMMENT, T_DOC_COMMENT_STAR => T_DOC_COMMENT_STAR, T_DOC_COMMENT_WHITESPACE => T_DOC_COMMENT_WHITESPACE, T_DOC_COMMENT_TAG => T_DOC_COMMENT_TAG, T_DOC_COMMENT_OPEN_TAG => T_DOC_COMMENT_OPEN_TAG, T_DOC_COMMENT_CLOSE_TAG => T_DOC_COMMENT_CLOSE_TAG, T_DOC_COMMENT_STRING => T_DOC_COMMENT_STRING, T_PHPCS_ENABLE => T_PHPCS_ENABLE, T_PHPCS_DISABLE => T_PHPCS_DISABLE, T_PHPCS_SET => T_PHPCS_SET, T_PHPCS_IGNORE => T_PHPCS_IGNORE, T_PHPCS_IGNORE_FILE => T_PHPCS_IGNORE_FILE, ]; /** * Tokens that are comments containing PHPCS instructions. * * @var array */ public static $phpcsCommentTokens = [ T_PHPCS_ENABLE => T_PHPCS_ENABLE, T_PHPCS_DISABLE => T_PHPCS_DISABLE, T_PHPCS_SET => T_PHPCS_SET, T_PHPCS_IGNORE => T_PHPCS_IGNORE, T_PHPCS_IGNORE_FILE => T_PHPCS_IGNORE_FILE, ]; /** * Tokens that represent strings. * * Note that T_STRINGS are NOT represented in this list. * * @var array */ public static $stringTokens = [ T_CONSTANT_ENCAPSED_STRING => T_CONSTANT_ENCAPSED_STRING, T_DOUBLE_QUOTED_STRING => T_DOUBLE_QUOTED_STRING, ]; /** * Tokens that represent text strings. * * @var array */ public static $textStringTokens = [ T_CONSTANT_ENCAPSED_STRING => T_CONSTANT_ENCAPSED_STRING, T_DOUBLE_QUOTED_STRING => T_DOUBLE_QUOTED_STRING, T_INLINE_HTML => T_INLINE_HTML, T_HEREDOC => T_HEREDOC, T_NOWDOC => T_NOWDOC, ]; /** * Tokens that represent brackets and parenthesis. * * @var array */ public static $bracketTokens = [ T_OPEN_CURLY_BRACKET => T_OPEN_CURLY_BRACKET, T_CLOSE_CURLY_BRACKET => T_CLOSE_CURLY_BRACKET, T_OPEN_SQUARE_BRACKET => T_OPEN_SQUARE_BRACKET, T_CLOSE_SQUARE_BRACKET => T_CLOSE_SQUARE_BRACKET, T_OPEN_PARENTHESIS => T_OPEN_PARENTHESIS, T_CLOSE_PARENTHESIS => T_CLOSE_PARENTHESIS, ]; /** * Tokens that include files. * * @var array */ public static $includeTokens = [ T_REQUIRE_ONCE => T_REQUIRE_ONCE, T_REQUIRE => T_REQUIRE, T_INCLUDE_ONCE => T_INCLUDE_ONCE, T_INCLUDE => T_INCLUDE, ]; /** * Tokens that make up a heredoc string. * * @var array */ public static $heredocTokens = [ T_START_HEREDOC => T_START_HEREDOC, T_END_HEREDOC => T_END_HEREDOC, T_HEREDOC => T_HEREDOC, T_START_NOWDOC => T_START_NOWDOC, T_END_NOWDOC => T_END_NOWDOC, T_NOWDOC => T_NOWDOC, ]; /** * Tokens that represent the names of called functions. * * Mostly, these are just strings. But PHP tokenizes some language * constructs and functions using their own tokens. * * @var array */ public static $functionNameTokens = [ T_STRING => T_STRING, T_EVAL => T_EVAL, T_EXIT => T_EXIT, T_INCLUDE => T_INCLUDE, T_INCLUDE_ONCE => T_INCLUDE_ONCE, T_REQUIRE => T_REQUIRE, T_REQUIRE_ONCE => T_REQUIRE_ONCE, T_ISSET => T_ISSET, T_UNSET => T_UNSET, T_EMPTY => T_EMPTY, T_SELF => T_SELF, T_STATIC => T_STATIC, ]; /** * Tokens that open class and object scopes. * * @var array */ public static $ooScopeTokens = [ T_CLASS => T_CLASS, T_ANON_CLASS => T_ANON_CLASS, T_INTERFACE => T_INTERFACE, T_TRAIT => T_TRAIT, ]; /** * Given a token, returns the name of the token. * * If passed an integer, the token name is sourced from PHP's token_name() * function. If passed a string, it is assumed to be a PHPCS-supplied token * that begins with PHPCS_T_, so the name is sourced from the token value itself. * * @param int|string $token The token to get the name for. * * @return string */ public static function tokenName($token) { if (is_string($token) === false) { // PHP-supplied token name. return token_name($token); } return substr($token, 6); }//end tokenName() /** * Returns the highest weighted token type. * * Tokens are weighted by their approximate frequency of appearance in code * - the less frequently they appear in the code, the higher the weighting. * For example T_CLASS tokens appear very infrequently in a file, and * therefore have a high weighting. * * Returns false if there are no weightings for any of the specified tokens. * * @param array $tokens The token types to get the highest weighted * type for. * * @return int|false The highest weighted token. */ public static function getHighestWeightedToken(array $tokens) { $highest = -1; $highestType = false; $weights = self::$weightings; foreach ($tokens as $token) { if (isset($weights[$token]) === true) { $weight = $weights[$token]; } else { $weight = 0; } if ($weight > $highest) { $highest = $weight; $highestType = $token; } } return $highestType; }//end getHighestWeightedToken() }//end class PHP_CodeSniffer-3.5.4/src/Config.php0000644000076500000240000020005013614652362017017 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer; use PHP_CodeSniffer\Exceptions\DeepExitException; use PHP_CodeSniffer\Exceptions\RuntimeException; class Config { /** * The current version. * * @var string */ const VERSION = '3.5.4'; /** * Package stability; either stable, beta or alpha. * * @var string */ const STABILITY = 'stable'; /** * An array of settings that PHPCS and PHPCBF accept. * * This array is not meant to be accessed directly. Instead, use the settings * as if they are class member vars so the __get() and __set() magic methods * can be used to validate the values. For example, to set the verbosity level to * level 2, use $this->verbosity = 2; instead of accessing this property directly. * * The list of settings are: * * string[] files The files and directories to check. * string[] standards The standards being used for checking. * int verbosity How verbose the output should be. * 0: no unnecessary output * 1: basic output for files being checked * 2: ruleset and file parsing output * 3: sniff execution output * bool interactive Enable interactive checking mode. * bool parallel Check files in parallel. * bool cache Enable the use of the file cache. * bool cacheFile A file where the cache data should be written * bool colors Display colours in output. * bool explain Explain the coding standards. * bool local Process local files in directories only (no recursion). * bool showSources Show sniff source codes in report output. * bool showProgress Show basic progress information while running. * bool quiet Quiet mode; disables progress and verbose output. * bool annotations Process phpcs: annotations. * int tabWidth How many spaces each tab is worth. * string encoding The encoding of the files being checked. * string[] sniffs The sniffs that should be used for checking. * If empty, all sniffs in the supplied standards will be used. * string[] exclude The sniffs that should be excluded from checking. * If empty, all sniffs in the supplied standards will be used. * string[] ignored Regular expressions used to ignore files and folders during checking. * string reportFile A file where the report output should be written. * string generator The documentation generator to use. * string filter The filter to use for the run. * string[] bootstrap One of more files to include before the run begins. * int reportWidth The maximum number of columns that reports should use for output. * Set to "auto" for have this value changed to the width of the terminal. * int errorSeverity The minimum severity an error must have to be displayed. * int warningSeverity The minimum severity a warning must have to be displayed. * bool recordErrors Record the content of error messages as well as error counts. * string suffix A suffix to add to fixed files. * string basepath A file system location to strip from the paths of files shown in reports. * bool stdin Read content from STDIN instead of supplied files. * string stdinContent Content passed directly to PHPCS on STDIN. * string stdinPath The path to use for content passed on STDIN. * * array extensions File extensions that should be checked, and what tokenizer to use. * E.g., array('inc' => 'PHP'); * array reports The reports to use for printing output after the run. * The format of the array is: * array( * 'reportName1' => 'outputFile', * 'reportName2' => null, * ); * If the array value is NULL, the report will be written to the screen. * * string[] unknown Any arguments gathered on the command line that are unknown to us. * E.g., using `phpcs -c` will give array('c'); * * @var array */ private $settings = [ 'files' => null, 'standards' => null, 'verbosity' => null, 'interactive' => null, 'parallel' => null, 'cache' => null, 'cacheFile' => null, 'colors' => null, 'explain' => null, 'local' => null, 'showSources' => null, 'showProgress' => null, 'quiet' => null, 'annotations' => null, 'tabWidth' => null, 'encoding' => null, 'extensions' => null, 'sniffs' => null, 'exclude' => null, 'ignored' => null, 'reportFile' => null, 'generator' => null, 'filter' => null, 'bootstrap' => null, 'reports' => null, 'basepath' => null, 'reportWidth' => null, 'errorSeverity' => null, 'warningSeverity' => null, 'recordErrors' => null, 'suffix' => null, 'stdin' => null, 'stdinContent' => null, 'stdinPath' => null, 'unknown' => null, ]; /** * Whether or not to kill the process when an unknown command line arg is found. * * If FALSE, arguments that are not command line options or file/directory paths * will be ignored and execution will continue. These values will be stored in * $this->unknown. * * @var boolean */ public $dieOnUnknownArg; /** * The current command line arguments we are processing. * * @var string[] */ private $cliArgs = []; /** * Command line values that the user has supplied directly. * * @var array */ private static $overriddenDefaults = []; /** * Config file data that has been loaded for the run. * * @var array */ private static $configData = null; /** * The full path to the config data file that has been loaded. * * @var string */ private static $configDataFile = null; /** * Automatically discovered executable utility paths. * * @var array */ private static $executablePaths = []; /** * Get the value of an inaccessible property. * * @param string $name The name of the property. * * @return mixed * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If the setting name is invalid. */ public function __get($name) { if (array_key_exists($name, $this->settings) === false) { throw new RuntimeException("ERROR: unable to get value of property \"$name\""); } return $this->settings[$name]; }//end __get() /** * Set the value of an inaccessible property. * * @param string $name The name of the property. * @param mixed $value The value of the property. * * @return void * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If the setting name is invalid. */ public function __set($name, $value) { if (array_key_exists($name, $this->settings) === false) { throw new RuntimeException("Can't __set() $name; setting doesn't exist"); } switch ($name) { case 'reportWidth' : // Support auto terminal width. if ($value === 'auto' && function_exists('shell_exec') === true && preg_match('|\d+ (\d+)|', shell_exec('stty size 2>&1'), $matches) === 1 ) { $value = (int) $matches[1]; } else { $value = (int) $value; } break; case 'standards' : $cleaned = []; // Check if the standard name is valid, or if the case is invalid. $installedStandards = Util\Standards::getInstalledStandards(); foreach ($value as $standard) { foreach ($installedStandards as $validStandard) { if (strtolower($standard) === strtolower($validStandard)) { $standard = $validStandard; break; } } $cleaned[] = $standard; } $value = $cleaned; break; default : // No validation required. break; }//end switch $this->settings[$name] = $value; }//end __set() /** * Check if the value of an inaccessible property is set. * * @param string $name The name of the property. * * @return bool */ public function __isset($name) { return isset($this->settings[$name]); }//end __isset() /** * Unset the value of an inaccessible property. * * @param string $name The name of the property. * * @return void */ public function __unset($name) { $this->settings[$name] = null; }//end __unset() /** * Get the array of all config settings. * * @return array */ public function getSettings() { return $this->settings; }//end getSettings() /** * Set the array of all config settings. * * @param array $settings The array of config settings. * * @return void */ public function setSettings($settings) { return $this->settings = $settings; }//end setSettings() /** * Creates a Config object and populates it with command line values. * * @param array $cliArgs An array of values gathered from CLI args. * @param bool $dieOnUnknownArg Whether or not to kill the process when an * unknown command line arg is found. * * @return void */ public function __construct(array $cliArgs=[], $dieOnUnknownArg=true) { if (defined('PHP_CODESNIFFER_IN_TESTS') === true) { // Let everything through during testing so that we can // make use of PHPUnit command line arguments as well. $this->dieOnUnknownArg = false; } else { $this->dieOnUnknownArg = $dieOnUnknownArg; } if (empty($cliArgs) === true) { $cliArgs = $_SERVER['argv']; array_shift($cliArgs); } $this->restoreDefaults(); $this->setCommandLineValues($cliArgs); if (isset(self::$overriddenDefaults['standards']) === false) { // They did not supply a standard to use. // Look for a default ruleset in the current directory or higher. $currentDir = getcwd(); $defaultFiles = [ '.phpcs.xml', 'phpcs.xml', '.phpcs.xml.dist', 'phpcs.xml.dist', ]; do { foreach ($defaultFiles as $defaultFilename) { $default = $currentDir.DIRECTORY_SEPARATOR.$defaultFilename; if (is_file($default) === true) { $this->standards = [$default]; break(2); } } $lastDir = $currentDir; $currentDir = dirname($currentDir); } while ($currentDir !== '.' && $currentDir !== $lastDir && @is_readable($currentDir) === true); }//end if if (defined('STDIN') === false || strtoupper(substr(PHP_OS, 0, 3)) === 'WIN' ) { return; } $handle = fopen('php://stdin', 'r'); // Check for content on STDIN. if ($this->stdin === true || (Util\Common::isStdinATTY() === false && feof($handle) === false) ) { $readStreams = [$handle]; $writeSteams = null; $fileContents = ''; while (is_resource($handle) === true && feof($handle) === false) { // Set a timeout of 200ms. if (stream_select($readStreams, $writeSteams, $writeSteams, 0, 200000) === 0) { break; } $fileContents .= fgets($handle); } if (trim($fileContents) !== '') { $this->stdin = true; $this->stdinContent = $fileContents; self::$overriddenDefaults['stdin'] = true; self::$overriddenDefaults['stdinContent'] = true; } }//end if fclose($handle); }//end __construct() /** * Set the command line values. * * @param array $args An array of command line arguments to set. * * @return void */ public function setCommandLineValues($args) { $this->cliArgs = $args; $numArgs = count($args); for ($i = 0; $i < $numArgs; $i++) { $arg = $this->cliArgs[$i]; if ($arg === '') { continue; } if ($arg[0] === '-') { if ($arg === '-') { // Asking to read from STDIN. $this->stdin = true; self::$overriddenDefaults['stdin'] = true; continue; } if ($arg === '--') { // Empty argument, ignore it. continue; } if ($arg[1] === '-') { $this->processLongArgument(substr($arg, 2), $i); } else { $switches = str_split($arg); foreach ($switches as $switch) { if ($switch === '-') { continue; } $this->processShortArgument($switch, $i); } } } else { $this->processUnknownArgument($arg, $i); }//end if }//end for }//end setCommandLineValues() /** * Restore default values for all possible command line arguments. * * @return array */ public function restoreDefaults() { $this->files = []; $this->standards = ['PEAR']; $this->verbosity = 0; $this->interactive = false; $this->cache = false; $this->cacheFile = null; $this->colors = false; $this->explain = false; $this->local = false; $this->showSources = false; $this->showProgress = false; $this->quiet = false; $this->annotations = true; $this->parallel = 1; $this->tabWidth = 0; $this->encoding = 'utf-8'; $this->extensions = [ 'php' => 'PHP', 'inc' => 'PHP', 'js' => 'JS', 'css' => 'CSS', ]; $this->sniffs = []; $this->exclude = []; $this->ignored = []; $this->reportFile = null; $this->generator = null; $this->filter = null; $this->bootstrap = []; $this->basepath = null; $this->reports = ['full' => null]; $this->reportWidth = 'auto'; $this->errorSeverity = 5; $this->warningSeverity = 5; $this->recordErrors = true; $this->suffix = ''; $this->stdin = false; $this->stdinContent = null; $this->stdinPath = null; $this->unknown = []; $standard = self::getConfigData('default_standard'); if ($standard !== null) { $this->standards = explode(',', $standard); } $reportFormat = self::getConfigData('report_format'); if ($reportFormat !== null) { $this->reports = [$reportFormat => null]; } $tabWidth = self::getConfigData('tab_width'); if ($tabWidth !== null) { $this->tabWidth = (int) $tabWidth; } $encoding = self::getConfigData('encoding'); if ($encoding !== null) { $this->encoding = strtolower($encoding); } $severity = self::getConfigData('severity'); if ($severity !== null) { $this->errorSeverity = (int) $severity; $this->warningSeverity = (int) $severity; } $severity = self::getConfigData('error_severity'); if ($severity !== null) { $this->errorSeverity = (int) $severity; } $severity = self::getConfigData('warning_severity'); if ($severity !== null) { $this->warningSeverity = (int) $severity; } $showWarnings = self::getConfigData('show_warnings'); if ($showWarnings !== null) { $showWarnings = (bool) $showWarnings; if ($showWarnings === false) { $this->warningSeverity = 0; } } $reportWidth = self::getConfigData('report_width'); if ($reportWidth !== null) { $this->reportWidth = $reportWidth; } $showProgress = self::getConfigData('show_progress'); if ($showProgress !== null) { $this->showProgress = (bool) $showProgress; } $quiet = self::getConfigData('quiet'); if ($quiet !== null) { $this->quiet = (bool) $quiet; } $colors = self::getConfigData('colors'); if ($colors !== null) { $this->colors = (bool) $colors; } if (defined('PHP_CODESNIFFER_IN_TESTS') === false) { $cache = self::getConfigData('cache'); if ($cache !== null) { $this->cache = (bool) $cache; } $parallel = self::getConfigData('parallel'); if ($parallel !== null) { $this->parallel = max((int) $parallel, 1); } } }//end restoreDefaults() /** * Processes a short (-e) command line argument. * * @param string $arg The command line argument. * @param int $pos The position of the argument on the command line. * * @return void * @throws \PHP_CodeSniffer\Exceptions\DeepExitException */ public function processShortArgument($arg, $pos) { switch ($arg) { case 'h': case '?': ob_start(); $this->printUsage(); $output = ob_get_contents(); ob_end_clean(); throw new DeepExitException($output, 0); case 'i' : ob_start(); Util\Standards::printInstalledStandards(); $output = ob_get_contents(); ob_end_clean(); throw new DeepExitException($output, 0); case 'v' : if ($this->quiet === true) { // Ignore when quiet mode is enabled. break; } $this->verbosity++; self::$overriddenDefaults['verbosity'] = true; break; case 'l' : $this->local = true; self::$overriddenDefaults['local'] = true; break; case 's' : $this->showSources = true; self::$overriddenDefaults['showSources'] = true; break; case 'a' : $this->interactive = true; self::$overriddenDefaults['interactive'] = true; break; case 'e': $this->explain = true; self::$overriddenDefaults['explain'] = true; break; case 'p' : if ($this->quiet === true) { // Ignore when quiet mode is enabled. break; } $this->showProgress = true; self::$overriddenDefaults['showProgress'] = true; break; case 'q' : // Quiet mode disables a few other settings as well. $this->quiet = true; $this->showProgress = false; $this->verbosity = 0; self::$overriddenDefaults['quiet'] = true; break; case 'm' : $this->recordErrors = false; self::$overriddenDefaults['recordErrors'] = true; break; case 'd' : $ini = explode('=', $this->cliArgs[($pos + 1)]); $this->cliArgs[($pos + 1)] = ''; if (isset($ini[1]) === true) { ini_set($ini[0], $ini[1]); } else { ini_set($ini[0], true); } break; case 'n' : if (isset(self::$overriddenDefaults['warningSeverity']) === false) { $this->warningSeverity = 0; self::$overriddenDefaults['warningSeverity'] = true; } break; case 'w' : if (isset(self::$overriddenDefaults['warningSeverity']) === false) { $this->warningSeverity = $this->errorSeverity; self::$overriddenDefaults['warningSeverity'] = true; } break; default: if ($this->dieOnUnknownArg === false) { $unknown = $this->unknown; $unknown[] = $arg; $this->unknown = $unknown; } else { $this->processUnknownArgument('-'.$arg, $pos); } }//end switch }//end processShortArgument() /** * Processes a long (--example) command line argument. * * @param string $arg The command line argument. * @param int $pos The position of the argument on the command line. * * @return void * @throws \PHP_CodeSniffer\Exceptions\DeepExitException */ public function processLongArgument($arg, $pos) { switch ($arg) { case 'help': ob_start(); $this->printUsage(); $output = ob_get_contents(); ob_end_clean(); throw new DeepExitException($output, 0); case 'version': $output = 'PHP_CodeSniffer version '.self::VERSION.' ('.self::STABILITY.') '; $output .= 'by Squiz (http://www.squiz.net)'.PHP_EOL; throw new DeepExitException($output, 0); case 'colors': if (isset(self::$overriddenDefaults['colors']) === true) { break; } $this->colors = true; self::$overriddenDefaults['colors'] = true; break; case 'no-colors': if (isset(self::$overriddenDefaults['colors']) === true) { break; } $this->colors = false; self::$overriddenDefaults['colors'] = true; break; case 'cache': if (isset(self::$overriddenDefaults['cache']) === true) { break; } if (defined('PHP_CODESNIFFER_IN_TESTS') === false) { $this->cache = true; self::$overriddenDefaults['cache'] = true; } break; case 'no-cache': if (isset(self::$overriddenDefaults['cache']) === true) { break; } $this->cache = false; self::$overriddenDefaults['cache'] = true; break; case 'ignore-annotations': if (isset(self::$overriddenDefaults['annotations']) === true) { break; } $this->annotations = false; self::$overriddenDefaults['annotations'] = true; break; case 'config-set': if (isset($this->cliArgs[($pos + 1)]) === false || isset($this->cliArgs[($pos + 2)]) === false ) { $error = 'ERROR: Setting a config option requires a name and value'.PHP_EOL.PHP_EOL; $error .= $this->printShortUsage(true); throw new DeepExitException($error, 3); } $key = $this->cliArgs[($pos + 1)]; $value = $this->cliArgs[($pos + 2)]; $current = self::getConfigData($key); try { $this->setConfigData($key, $value); } catch (\Exception $e) { throw new DeepExitException($e->getMessage().PHP_EOL, 3); } $output = 'Using config file: '.self::$configDataFile.PHP_EOL.PHP_EOL; if ($current === null) { $output .= "Config value \"$key\" added successfully".PHP_EOL; } else { $output .= "Config value \"$key\" updated successfully; old value was \"$current\"".PHP_EOL; } throw new DeepExitException($output, 0); case 'config-delete': if (isset($this->cliArgs[($pos + 1)]) === false) { $error = 'ERROR: Deleting a config option requires the name of the option'.PHP_EOL.PHP_EOL; $error .= $this->printShortUsage(true); throw new DeepExitException($error, 3); } $output = 'Using config file: '.self::$configDataFile.PHP_EOL.PHP_EOL; $key = $this->cliArgs[($pos + 1)]; $current = self::getConfigData($key); if ($current === null) { $output .= "Config value \"$key\" has not been set".PHP_EOL; } else { try { $this->setConfigData($key, null); } catch (\Exception $e) { throw new DeepExitException($e->getMessage().PHP_EOL, 3); } $output .= "Config value \"$key\" removed successfully; old value was \"$current\"".PHP_EOL; } throw new DeepExitException($output, 0); case 'config-show': ob_start(); $data = self::getAllConfigData(); echo 'Using config file: '.self::$configDataFile.PHP_EOL.PHP_EOL; $this->printConfigData($data); $output = ob_get_contents(); ob_end_clean(); throw new DeepExitException($output, 0); case 'runtime-set': if (isset($this->cliArgs[($pos + 1)]) === false || isset($this->cliArgs[($pos + 2)]) === false ) { $error = 'ERROR: Setting a runtime config option requires a name and value'.PHP_EOL.PHP_EOL; $error .= $this->printShortUsage(true); throw new DeepExitException($error, 3); } $key = $this->cliArgs[($pos + 1)]; $value = $this->cliArgs[($pos + 2)]; $this->cliArgs[($pos + 1)] = ''; $this->cliArgs[($pos + 2)] = ''; self::setConfigData($key, $value, true); if (isset(self::$overriddenDefaults['runtime-set']) === false) { self::$overriddenDefaults['runtime-set'] = []; } self::$overriddenDefaults['runtime-set'][$key] = true; break; default: if (substr($arg, 0, 7) === 'sniffs=') { if (isset(self::$overriddenDefaults['sniffs']) === true) { break; } $sniffs = explode(',', substr($arg, 7)); foreach ($sniffs as $sniff) { if (substr_count($sniff, '.') !== 2) { $error = 'ERROR: The specified sniff code "'.$sniff.'" is invalid'.PHP_EOL.PHP_EOL; $error .= $this->printShortUsage(true); throw new DeepExitException($error, 3); } } $this->sniffs = $sniffs; self::$overriddenDefaults['sniffs'] = true; } else if (substr($arg, 0, 8) === 'exclude=') { if (isset(self::$overriddenDefaults['exclude']) === true) { break; } $sniffs = explode(',', substr($arg, 8)); foreach ($sniffs as $sniff) { if (substr_count($sniff, '.') !== 2) { $error = 'ERROR: The specified sniff code "'.$sniff.'" is invalid'.PHP_EOL.PHP_EOL; $error .= $this->printShortUsage(true); throw new DeepExitException($error, 3); } } $this->exclude = $sniffs; self::$overriddenDefaults['exclude'] = true; } else if (defined('PHP_CODESNIFFER_IN_TESTS') === false && substr($arg, 0, 6) === 'cache=' ) { if ((isset(self::$overriddenDefaults['cache']) === true && $this->cache === false) || isset(self::$overriddenDefaults['cacheFile']) === true ) { break; } // Turn caching on. $this->cache = true; self::$overriddenDefaults['cache'] = true; $this->cacheFile = Util\Common::realpath(substr($arg, 6)); // It may not exist and return false instead. if ($this->cacheFile === false) { $this->cacheFile = substr($arg, 6); $dir = dirname($this->cacheFile); if (is_dir($dir) === false) { $error = 'ERROR: The specified cache file path "'.$this->cacheFile.'" points to a non-existent directory'.PHP_EOL.PHP_EOL; $error .= $this->printShortUsage(true); throw new DeepExitException($error, 3); } if ($dir === '.') { // Passed cache file is a file in the current directory. $this->cacheFile = getcwd().'/'.basename($this->cacheFile); } else { if ($dir[0] === '/') { // An absolute path. $dir = Util\Common::realpath($dir); } else { $dir = Util\Common::realpath(getcwd().'/'.$dir); } if ($dir !== false) { // Cache file path is relative. $this->cacheFile = $dir.'/'.basename($this->cacheFile); } } }//end if self::$overriddenDefaults['cacheFile'] = true; if (is_dir($this->cacheFile) === true) { $error = 'ERROR: The specified cache file path "'.$this->cacheFile.'" is a directory'.PHP_EOL.PHP_EOL; $error .= $this->printShortUsage(true); throw new DeepExitException($error, 3); } } else if (substr($arg, 0, 10) === 'bootstrap=') { $files = explode(',', substr($arg, 10)); $bootstrap = []; foreach ($files as $file) { $path = Util\Common::realpath($file); if ($path === false) { $error = 'ERROR: The specified bootstrap file "'.$file.'" does not exist'.PHP_EOL.PHP_EOL; $error .= $this->printShortUsage(true); throw new DeepExitException($error, 3); } $bootstrap[] = $path; } $this->bootstrap = array_merge($this->bootstrap, $bootstrap); self::$overriddenDefaults['bootstrap'] = true; } else if (substr($arg, 0, 10) === 'file-list=') { $fileList = substr($arg, 10); $path = Util\Common::realpath($fileList); if ($path === false) { $error = 'ERROR: The specified file list "'.$fileList.'" does not exist'.PHP_EOL.PHP_EOL; $error .= $this->printShortUsage(true); throw new DeepExitException($error, 3); } $files = file($path); foreach ($files as $inputFile) { $inputFile = trim($inputFile); // Skip empty lines. if ($inputFile === '') { continue; } $this->processFilePath($inputFile); } } else if (substr($arg, 0, 11) === 'stdin-path=') { if (isset(self::$overriddenDefaults['stdinPath']) === true) { break; } $this->stdinPath = Util\Common::realpath(substr($arg, 11)); // It may not exist and return false instead, so use whatever they gave us. if ($this->stdinPath === false) { $this->stdinPath = trim(substr($arg, 11)); } self::$overriddenDefaults['stdinPath'] = true; } else if (PHP_CODESNIFFER_CBF === false && substr($arg, 0, 12) === 'report-file=') { if (isset(self::$overriddenDefaults['reportFile']) === true) { break; } $this->reportFile = Util\Common::realpath(substr($arg, 12)); // It may not exist and return false instead. if ($this->reportFile === false) { $this->reportFile = substr($arg, 12); $dir = Util\Common::realpath(dirname($this->reportFile)); if (is_dir($dir) === false) { $error = 'ERROR: The specified report file path "'.$this->reportFile.'" points to a non-existent directory'.PHP_EOL.PHP_EOL; $error .= $this->printShortUsage(true); throw new DeepExitException($error, 3); } $this->reportFile = $dir.'/'.basename($this->reportFile); }//end if self::$overriddenDefaults['reportFile'] = true; if (is_dir($this->reportFile) === true) { $error = 'ERROR: The specified report file path "'.$this->reportFile.'" is a directory'.PHP_EOL.PHP_EOL; $error .= $this->printShortUsage(true); throw new DeepExitException($error, 3); } } else if (substr($arg, 0, 13) === 'report-width=') { if (isset(self::$overriddenDefaults['reportWidth']) === true) { break; } $this->reportWidth = substr($arg, 13); self::$overriddenDefaults['reportWidth'] = true; } else if (substr($arg, 0, 9) === 'basepath=') { if (isset(self::$overriddenDefaults['basepath']) === true) { break; } self::$overriddenDefaults['basepath'] = true; if (substr($arg, 9) === '') { $this->basepath = null; break; } $this->basepath = Util\Common::realpath(substr($arg, 9)); // It may not exist and return false instead. if ($this->basepath === false) { $this->basepath = substr($arg, 9); } if (is_dir($this->basepath) === false) { $error = 'ERROR: The specified basepath "'.$this->basepath.'" points to a non-existent directory'.PHP_EOL.PHP_EOL; $error .= $this->printShortUsage(true); throw new DeepExitException($error, 3); } } else if ((substr($arg, 0, 7) === 'report=' || substr($arg, 0, 7) === 'report-')) { $reports = []; if ($arg[6] === '-') { // This is a report with file output. $split = strpos($arg, '='); if ($split === false) { $report = substr($arg, 7); $output = null; } else { $report = substr($arg, 7, ($split - 7)); $output = substr($arg, ($split + 1)); if ($output === false) { $output = null; } else { $dir = Util\Common::realpath(dirname($output)); if (is_dir($dir) === false) { $error = 'ERROR: The specified '.$report.' report file path "'.$output.'" points to a non-existent directory'.PHP_EOL.PHP_EOL; $error .= $this->printShortUsage(true); throw new DeepExitException($error, 3); } $output = $dir.'/'.basename($output); if (is_dir($output) === true) { $error = 'ERROR: The specified '.$report.' report file path "'.$output.'" is a directory'.PHP_EOL.PHP_EOL; $error .= $this->printShortUsage(true); throw new DeepExitException($error, 3); } }//end if }//end if $reports[$report] = $output; } else { // This is a single report. if (isset(self::$overriddenDefaults['reports']) === true) { break; } $reportNames = explode(',', substr($arg, 7)); foreach ($reportNames as $report) { $reports[$report] = null; } }//end if // Remove the default value so the CLI value overrides it. if (isset(self::$overriddenDefaults['reports']) === false) { $this->reports = $reports; } else { $this->reports = array_merge($this->reports, $reports); } self::$overriddenDefaults['reports'] = true; } else if (substr($arg, 0, 7) === 'filter=') { if (isset(self::$overriddenDefaults['filter']) === true) { break; } $this->filter = substr($arg, 7); self::$overriddenDefaults['filter'] = true; } else if (substr($arg, 0, 9) === 'standard=') { $standards = trim(substr($arg, 9)); if ($standards !== '') { $this->standards = explode(',', $standards); } self::$overriddenDefaults['standards'] = true; } else if (substr($arg, 0, 11) === 'extensions=') { if (isset(self::$overriddenDefaults['extensions']) === true) { break; } $extensions = explode(',', substr($arg, 11)); $newExtensions = []; foreach ($extensions as $ext) { $slash = strpos($ext, '/'); if ($slash !== false) { // They specified the tokenizer too. list($ext, $tokenizer) = explode('/', $ext); $newExtensions[$ext] = strtoupper($tokenizer); continue; } if (isset($this->extensions[$ext]) === true) { $newExtensions[$ext] = $this->extensions[$ext]; } else { $newExtensions[$ext] = 'PHP'; } } $this->extensions = $newExtensions; self::$overriddenDefaults['extensions'] = true; } else if (substr($arg, 0, 7) === 'suffix=') { if (isset(self::$overriddenDefaults['suffix']) === true) { break; } $this->suffix = substr($arg, 7); self::$overriddenDefaults['suffix'] = true; } else if (substr($arg, 0, 9) === 'parallel=') { if (isset(self::$overriddenDefaults['parallel']) === true) { break; } $this->parallel = max((int) substr($arg, 9), 1); self::$overriddenDefaults['parallel'] = true; } else if (substr($arg, 0, 9) === 'severity=') { $this->errorSeverity = (int) substr($arg, 9); $this->warningSeverity = $this->errorSeverity; if (isset(self::$overriddenDefaults['errorSeverity']) === false) { self::$overriddenDefaults['errorSeverity'] = true; } if (isset(self::$overriddenDefaults['warningSeverity']) === false) { self::$overriddenDefaults['warningSeverity'] = true; } } else if (substr($arg, 0, 15) === 'error-severity=') { if (isset(self::$overriddenDefaults['errorSeverity']) === true) { break; } $this->errorSeverity = (int) substr($arg, 15); self::$overriddenDefaults['errorSeverity'] = true; } else if (substr($arg, 0, 17) === 'warning-severity=') { if (isset(self::$overriddenDefaults['warningSeverity']) === true) { break; } $this->warningSeverity = (int) substr($arg, 17); self::$overriddenDefaults['warningSeverity'] = true; } else if (substr($arg, 0, 7) === 'ignore=') { if (isset(self::$overriddenDefaults['ignored']) === true) { break; } // Split the ignore string on commas, unless the comma is escaped // using 1 or 3 slashes (\, or \\\,). $patterns = preg_split( '/(?<=(?ignored = $ignored; self::$overriddenDefaults['ignored'] = true; } else if (substr($arg, 0, 10) === 'generator=' && PHP_CODESNIFFER_CBF === false ) { if (isset(self::$overriddenDefaults['generator']) === true) { break; } $this->generator = substr($arg, 10); self::$overriddenDefaults['generator'] = true; } else if (substr($arg, 0, 9) === 'encoding=') { if (isset(self::$overriddenDefaults['encoding']) === true) { break; } $this->encoding = strtolower(substr($arg, 9)); self::$overriddenDefaults['encoding'] = true; } else if (substr($arg, 0, 10) === 'tab-width=') { if (isset(self::$overriddenDefaults['tabWidth']) === true) { break; } $this->tabWidth = (int) substr($arg, 10); self::$overriddenDefaults['tabWidth'] = true; } else { if ($this->dieOnUnknownArg === false) { $eqPos = strpos($arg, '='); try { if ($eqPos === false) { $this->values[$arg] = $arg; } else { $value = substr($arg, ($eqPos + 1)); $arg = substr($arg, 0, $eqPos); $this->values[$arg] = $value; } } catch (RuntimeException $e) { // Value is not valid, so just ignore it. } } else { $this->processUnknownArgument('--'.$arg, $pos); } }//end if break; }//end switch }//end processLongArgument() /** * Processes an unknown command line argument. * * Assumes all unknown arguments are files and folders to check. * * @param string $arg The command line argument. * @param int $pos The position of the argument on the command line. * * @return void * @throws \PHP_CodeSniffer\Exceptions\DeepExitException */ public function processUnknownArgument($arg, $pos) { // We don't know about any additional switches; just files. if ($arg[0] === '-') { if ($this->dieOnUnknownArg === false) { return; } $error = "ERROR: option \"$arg\" not known".PHP_EOL.PHP_EOL; $error .= $this->printShortUsage(true); throw new DeepExitException($error, 3); } $this->processFilePath($arg); }//end processUnknownArgument() /** * Processes a file path and add it to the file list. * * @param string $path The path to the file to add. * * @return void * @throws \PHP_CodeSniffer\Exceptions\DeepExitException */ public function processFilePath($path) { // If we are processing STDIN, don't record any files to check. if ($this->stdin === true) { return; } $file = Util\Common::realpath($path); if (file_exists($file) === false) { if ($this->dieOnUnknownArg === false) { return; } $error = 'ERROR: The file "'.$path.'" does not exist.'.PHP_EOL.PHP_EOL; $error .= $this->printShortUsage(true); throw new DeepExitException($error, 3); } else { // Can't modify the files array directly because it's not a real // class member, so need to use this little get/modify/set trick. $files = $this->files; $files[] = $file; $this->files = $files; self::$overriddenDefaults['files'] = true; } }//end processFilePath() /** * Prints out the usage information for this script. * * @return void */ public function printUsage() { echo PHP_EOL; if (PHP_CODESNIFFER_CBF === true) { $this->printPHPCBFUsage(); } else { $this->printPHPCSUsage(); } echo PHP_EOL; }//end printUsage() /** * Prints out the short usage information for this script. * * @param bool $return If TRUE, the usage string is returned * instead of output to screen. * * @return string|void */ public function printShortUsage($return=false) { if (PHP_CODESNIFFER_CBF === true) { $usage = 'Run "phpcbf --help" for usage information'; } else { $usage = 'Run "phpcs --help" for usage information'; } $usage .= PHP_EOL.PHP_EOL; if ($return === true) { return $usage; } echo $usage; }//end printShortUsage() /** * Prints out the usage information for PHPCS. * * @return void */ public function printPHPCSUsage() { echo 'Usage: phpcs [-nwlsaepqvi] [-d key[=value]] [--colors] [--no-colors]'.PHP_EOL; echo ' [--cache[=]] [--no-cache] [--tab-width=]'.PHP_EOL; echo ' [--report=] [--report-file=] [--report-=]'.PHP_EOL; echo ' [--report-width=] [--basepath=] [--bootstrap=]'.PHP_EOL; echo ' [--severity=] [--error-severity=] [--warning-severity=]'.PHP_EOL; echo ' [--runtime-set key value] [--config-set key value] [--config-delete key] [--config-show]'.PHP_EOL; echo ' [--standard=] [--sniffs=] [--exclude=]'.PHP_EOL; echo ' [--encoding=] [--parallel=] [--generator=]'.PHP_EOL; echo ' [--extensions=] [--ignore=] [--ignore-annotations]'.PHP_EOL; echo ' [--stdin-path=] [--file-list=] [--filter=] - ...'.PHP_EOL; echo PHP_EOL; echo ' - Check STDIN instead of local files and directories'.PHP_EOL; echo ' -n Do not print warnings (shortcut for --warning-severity=0)'.PHP_EOL; echo ' -w Print both warnings and errors (this is the default)'.PHP_EOL; echo ' -l Local directory only, no recursion'.PHP_EOL; echo ' -s Show sniff codes in all reports'.PHP_EOL; echo ' -a Run interactively'.PHP_EOL; echo ' -e Explain a standard by showing the sniffs it includes'.PHP_EOL; echo ' -p Show progress of the run'.PHP_EOL; echo ' -q Quiet mode; disables progress and verbose output'.PHP_EOL; echo ' -m Stop error messages from being recorded'.PHP_EOL; echo ' (saves a lot of memory, but stops many reports from being used)'.PHP_EOL; echo ' -v Print processed files'.PHP_EOL; echo ' -vv Print ruleset and token output'.PHP_EOL; echo ' -vvv Print sniff processing information'.PHP_EOL; echo ' -i Show a list of installed coding standards'.PHP_EOL; echo ' -d Set the [key] php.ini value to [value] or [true] if value is omitted'.PHP_EOL; echo PHP_EOL; echo ' --help Print this help message'.PHP_EOL; echo ' --version Print version information'.PHP_EOL; echo ' --colors Use colors in output'.PHP_EOL; echo ' --no-colors Do not use colors in output (this is the default)'.PHP_EOL; echo ' --cache Cache results between runs'.PHP_EOL; echo ' --no-cache Do not cache results between runs (this is the default)'.PHP_EOL; echo ' --ignore-annotations Ignore all phpcs: annotations in code comments'.PHP_EOL; echo PHP_EOL; echo ' Use a specific file for caching (uses a temporary file by default)'.PHP_EOL; echo ' A path to strip from the front of file paths inside reports'.PHP_EOL; echo ' A comma separated list of files to run before processing begins'.PHP_EOL; echo ' The encoding of the files being checked (default is utf-8)'.PHP_EOL; echo ' A comma separated list of file extensions to check'.PHP_EOL; echo ' The type of the file can be specified using: ext/type'.PHP_EOL; echo ' e.g., module/php,es/js'.PHP_EOL; echo ' One or more files and/or directories to check'.PHP_EOL; echo ' A file containing a list of files and/or directories to check (one per line)'.PHP_EOL; echo ' Use either the "gitmodified" or "gitstaged" filter,'.PHP_EOL; echo ' or specify the path to a custom filter class'.PHP_EOL; echo ' Use either the "HTML", "Markdown" or "Text" generator'.PHP_EOL; echo ' (forces documentation generation instead of checking)'.PHP_EOL; echo ' A comma separated list of patterns to ignore files and directories'.PHP_EOL; echo ' How many files should be checked simultaneously (default is 1)'.PHP_EOL; echo ' Print either the "full", "xml", "checkstyle", "csv"'.PHP_EOL; echo ' "json", "junit", "emacs", "source", "summary", "diff"'.PHP_EOL; echo ' "svnblame", "gitblame", "hgblame" or "notifysend" report,'.PHP_EOL; echo ' or specify the path to a custom report class'.PHP_EOL; echo ' (the "full" report is printed by default)'.PHP_EOL; echo ' Write the report to the specified file path'.PHP_EOL; echo ' How many columns wide screen reports should be printed'.PHP_EOL; echo ' or set to "auto" to use current screen width, where supported'.PHP_EOL; echo ' The minimum severity required to display an error or warning'.PHP_EOL; echo ' A comma separated list of sniff codes to include or exclude from checking'.PHP_EOL; echo ' (all sniffs must be part of the specified standard)'.PHP_EOL; echo ' The name or path of the coding standard to use'.PHP_EOL; echo ' If processing STDIN, the file path that STDIN will be processed as'.PHP_EOL; echo ' The number of spaces each tab represents'.PHP_EOL; }//end printPHPCSUsage() /** * Prints out the usage information for PHPCBF. * * @return void */ public function printPHPCBFUsage() { echo 'Usage: phpcbf [-nwli] [-d key[=value]] [--ignore-annotations] [--bootstrap=]'.PHP_EOL; echo ' [--standard=] [--sniffs=] [--exclude=] [--suffix=]'.PHP_EOL; echo ' [--severity=] [--error-severity=] [--warning-severity=]'.PHP_EOL; echo ' [--tab-width=] [--encoding=] [--parallel=]'.PHP_EOL; echo ' [--basepath=] [--extensions=] [--ignore=]'.PHP_EOL; echo ' [--stdin-path=] [--file-list=] [--filter=] - ...'.PHP_EOL; echo PHP_EOL; echo ' - Fix STDIN instead of local files and directories'.PHP_EOL; echo ' -n Do not fix warnings (shortcut for --warning-severity=0)'.PHP_EOL; echo ' -w Fix both warnings and errors (on by default)'.PHP_EOL; echo ' -l Local directory only, no recursion'.PHP_EOL; echo ' -p Show progress of the run'.PHP_EOL; echo ' -q Quiet mode; disables progress and verbose output'.PHP_EOL; echo ' -v Print processed files'.PHP_EOL; echo ' -vv Print ruleset and token output'.PHP_EOL; echo ' -vvv Print sniff processing information'.PHP_EOL; echo ' -i Show a list of installed coding standards'.PHP_EOL; echo ' -d Set the [key] php.ini value to [value] or [true] if value is omitted'.PHP_EOL; echo PHP_EOL; echo ' --help Print this help message'.PHP_EOL; echo ' --version Print version information'.PHP_EOL; echo ' --ignore-annotations Ignore all phpcs: annotations in code comments'.PHP_EOL; echo PHP_EOL; echo ' A path to strip from the front of file paths inside reports'.PHP_EOL; echo ' A comma separated list of files to run before processing begins'.PHP_EOL; echo ' The encoding of the files being fixed (default is utf-8)'.PHP_EOL; echo ' A comma separated list of file extensions to fix'.PHP_EOL; echo ' The type of the file can be specified using: ext/type'.PHP_EOL; echo ' e.g., module/php,es/js'.PHP_EOL; echo ' One or more files and/or directories to fix'.PHP_EOL; echo ' A file containing a list of files and/or directories to fix (one per line)'.PHP_EOL; echo ' Use either the "gitmodified" or "gitstaged" filter,'.PHP_EOL; echo ' or specify the path to a custom filter class'.PHP_EOL; echo ' A comma separated list of patterns to ignore files and directories'.PHP_EOL; echo ' How many files should be fixed simultaneously (default is 1)'.PHP_EOL; echo ' The minimum severity required to fix an error or warning'.PHP_EOL; echo ' A comma separated list of sniff codes to include or exclude from fixing'.PHP_EOL; echo ' (all sniffs must be part of the specified standard)'.PHP_EOL; echo ' The name or path of the coding standard to use'.PHP_EOL; echo ' If processing STDIN, the file path that STDIN will be processed as'.PHP_EOL; echo ' Write modified files to a filename using this suffix'.PHP_EOL; echo ' ("diff" and "patch" are not used in this mode)'.PHP_EOL; echo ' The number of spaces each tab represents'.PHP_EOL; }//end printPHPCBFUsage() /** * Get a single config value. * * @param string $key The name of the config value. * * @return string|null * @see setConfigData() * @see getAllConfigData() */ public static function getConfigData($key) { $phpCodeSnifferConfig = self::getAllConfigData(); if ($phpCodeSnifferConfig === null) { return null; } if (isset($phpCodeSnifferConfig[$key]) === false) { return null; } return $phpCodeSnifferConfig[$key]; }//end getConfigData() /** * Get the path to an executable utility. * * @param string $name The name of the executable utility. * * @return string|null * @see getConfigData() */ public static function getExecutablePath($name) { $data = self::getConfigData($name.'_path'); if ($data !== null) { return $data; } if ($name === "php") { // For php, we know the executable path. There's no need to look it up. return PHP_BINARY; } if (array_key_exists($name, self::$executablePaths) === true) { return self::$executablePaths[$name]; } if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') { $cmd = 'where '.escapeshellarg($name).' 2> nul'; } else { $cmd = 'which '.escapeshellarg($name).' 2> /dev/null'; } $result = exec($cmd, $output, $retVal); if ($retVal !== 0) { $result = null; } self::$executablePaths[$name] = $result; return $result; }//end getExecutablePath() /** * Set a single config value. * * @param string $key The name of the config value. * @param string|null $value The value to set. If null, the config * entry is deleted, reverting it to the * default value. * @param boolean $temp Set this config data temporarily for this * script run. This will not write the config * data to the config file. * * @return bool * @see getConfigData() * @throws \PHP_CodeSniffer\Exceptions\DeepExitException If the config file can not be written. */ public static function setConfigData($key, $value, $temp=false) { if (isset(self::$overriddenDefaults['runtime-set']) === true && isset(self::$overriddenDefaults['runtime-set'][$key]) === true ) { return false; } if ($temp === false) { $path = ''; if (is_callable('\Phar::running') === true) { $path = \Phar::running(false); } if ($path !== '') { $configFile = dirname($path).DIRECTORY_SEPARATOR.'CodeSniffer.conf'; } else { $configFile = dirname(__DIR__).DIRECTORY_SEPARATOR.'CodeSniffer.conf'; if (is_file($configFile) === false && strpos('@data_dir@', '@data_dir') === false ) { // If data_dir was replaced, this is a PEAR install and we can // use the PEAR data dir to store the conf file. $configFile = '@data_dir@/PHP_CodeSniffer/CodeSniffer.conf'; } } if (is_file($configFile) === true && is_writable($configFile) === false ) { $error = 'ERROR: Config file '.$configFile.' is not writable'.PHP_EOL.PHP_EOL; throw new DeepExitException($error, 3); } }//end if $phpCodeSnifferConfig = self::getAllConfigData(); if ($value === null) { if (isset($phpCodeSnifferConfig[$key]) === true) { unset($phpCodeSnifferConfig[$key]); } } else { $phpCodeSnifferConfig[$key] = $value; } if ($temp === false) { $output = '<'.'?php'."\n".' $phpCodeSnifferConfig = '; $output .= var_export($phpCodeSnifferConfig, true); $output .= "\n?".'>'; if (file_put_contents($configFile, $output) === false) { $error = 'ERROR: Config file '.$configFile.' could not be written'.PHP_EOL.PHP_EOL; throw new DeepExitException($error, 3); } self::$configDataFile = $configFile; } self::$configData = $phpCodeSnifferConfig; // If the installed paths are being set, make sure all known // standards paths are added to the autoloader. if ($key === 'installed_paths') { $installedStandards = Util\Standards::getInstalledStandardDetails(); foreach ($installedStandards as $name => $details) { Autoload::addSearchPath($details['path'], $details['namespace']); } } return true; }//end setConfigData() /** * Get all config data. * * @return array * @see getConfigData() * @throws \PHP_CodeSniffer\Exceptions\DeepExitException If the config file could not be read. */ public static function getAllConfigData() { if (self::$configData !== null) { return self::$configData; } $path = ''; if (is_callable('\Phar::running') === true) { $path = \Phar::running(false); } if ($path !== '') { $configFile = dirname($path).DIRECTORY_SEPARATOR.'CodeSniffer.conf'; } else { $configFile = dirname(__DIR__).DIRECTORY_SEPARATOR.'CodeSniffer.conf'; if (is_file($configFile) === false && strpos('@data_dir@', '@data_dir') === false ) { $configFile = '@data_dir@/PHP_CodeSniffer/CodeSniffer.conf'; } } if (is_file($configFile) === false) { self::$configData = []; return []; } if (is_readable($configFile) === false) { $error = 'ERROR: Config file '.$configFile.' is not readable'.PHP_EOL.PHP_EOL; throw new DeepExitException($error, 3); } include $configFile; self::$configDataFile = $configFile; self::$configData = $phpCodeSnifferConfig; return self::$configData; }//end getAllConfigData() /** * Prints out the gathered config data. * * @param array $data The config data to print. * * @return void */ public function printConfigData($data) { $max = 0; $keys = array_keys($data); foreach ($keys as $key) { $len = strlen($key); if (strlen($key) > $max) { $max = $len; } } if ($max === 0) { return; } $max += 2; ksort($data); foreach ($data as $name => $value) { echo str_pad($name.': ', $max).$value.PHP_EOL; } }//end printConfigData() }//end class PHP_CodeSniffer-3.5.4/src/Fixer.php0000644000076500000240000005623213614652362016702 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Util\Common; class Fixer { /** * Is the fixer enabled and fixing a file? * * Sniffs should check this value to ensure they are not * doing extra processing to prepare for a fix when fixing is * not required. * * @var boolean */ public $enabled = false; /** * The number of times we have looped over a file. * * @var integer */ public $loops = 0; /** * The file being fixed. * * @var \PHP_CodeSniffer\Files\File */ private $currentFile = null; /** * The list of tokens that make up the file contents. * * This is a simplified list which just contains the token content and nothing * else. This is the array that is updated as fixes are made, not the file's * token array. Imploding this array will give you the file content back. * * @var array */ private $tokens = []; /** * A list of tokens that have already been fixed. * * We don't allow the same token to be fixed more than once each time * through a file as this can easily cause conflicts between sniffs. * * @var int[] */ private $fixedTokens = []; /** * The last value of each fixed token. * * If a token is being "fixed" back to its last value, the fix is * probably conflicting with another. * * @var array */ private $oldTokenValues = []; /** * A list of tokens that have been fixed during a changeset. * * All changes in changeset must be able to be applied, or else * the entire changeset is rejected. * * @var array */ private $changeset = []; /** * Is there an open changeset. * * @var boolean */ private $inChangeset = false; /** * Is the current fixing loop in conflict? * * @var boolean */ private $inConflict = false; /** * The number of fixes that have been performed. * * @var integer */ private $numFixes = 0; /** * Starts fixing a new file. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file being fixed. * * @return void */ public function startFile(File $phpcsFile) { $this->currentFile = $phpcsFile; $this->numFixes = 0; $this->fixedTokens = []; $tokens = $phpcsFile->getTokens(); $this->tokens = []; foreach ($tokens as $index => $token) { if (isset($token['orig_content']) === true) { $this->tokens[$index] = $token['orig_content']; } else { $this->tokens[$index] = $token['content']; } } }//end startFile() /** * Attempt to fix the file by processing it until no fixes are made. * * @return boolean */ public function fixFile() { $fixable = $this->currentFile->getFixableCount(); if ($fixable === 0) { // Nothing to fix. return false; } $this->enabled = true; $this->loops = 0; while ($this->loops < 50) { ob_start(); // Only needed once file content has changed. $contents = $this->getContents(); if (PHP_CODESNIFFER_VERBOSITY > 2) { @ob_end_clean(); echo '---START FILE CONTENT---'.PHP_EOL; $lines = explode($this->currentFile->eolChar, $contents); $max = strlen(count($lines)); foreach ($lines as $lineNum => $line) { $lineNum++; echo str_pad($lineNum, $max, ' ', STR_PAD_LEFT).'|'.$line.PHP_EOL; } echo '--- END FILE CONTENT ---'.PHP_EOL; ob_start(); } $this->inConflict = false; $this->currentFile->ruleset->populateTokenListeners(); $this->currentFile->setContent($contents); $this->currentFile->process(); ob_end_clean(); $this->loops++; if (PHP_CODESNIFFER_CBF === true && PHP_CODESNIFFER_VERBOSITY > 0) { echo "\r".str_repeat(' ', 80)."\r"; echo "\t=> Fixing file: $this->numFixes/$fixable violations remaining [made $this->loops pass"; if ($this->loops > 1) { echo 'es'; } echo ']... '; } if ($this->numFixes === 0 && $this->inConflict === false) { // Nothing left to do. break; } else if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "\t* fixed $this->numFixes violations, starting loop ".($this->loops + 1).' *'.PHP_EOL; } }//end while $this->enabled = false; if ($this->numFixes > 0) { if (PHP_CODESNIFFER_VERBOSITY > 1) { if (ob_get_level() > 0) { ob_end_clean(); } echo "\t*** Reached maximum number of loops with $this->numFixes violations left unfixed ***".PHP_EOL; ob_start(); } return false; } return true; }//end fixFile() /** * Generates a text diff of the original file and the new content. * * @param string $filePath Optional file path to diff the file against. * If not specified, the original version of the * file will be used. * @param boolean $colors Print coloured output or not. * * @return string */ public function generateDiff($filePath=null, $colors=true) { if ($filePath === null) { $filePath = $this->currentFile->getFilename(); } $cwd = getcwd().DIRECTORY_SEPARATOR; if (strpos($filePath, $cwd) === 0) { $filename = substr($filePath, strlen($cwd)); } else { $filename = $filePath; } $contents = $this->getContents(); $tempName = tempnam(sys_get_temp_dir(), 'phpcs-fixer'); $fixedFile = fopen($tempName, 'w'); fwrite($fixedFile, $contents); // We must use something like shell_exec() because whitespace at the end // of lines is critical to diff files. $filename = escapeshellarg($filename); $cmd = "diff -u -L$filename -LPHP_CodeSniffer $filename \"$tempName\""; $diff = shell_exec($cmd); fclose($fixedFile); if (is_file($tempName) === true) { unlink($tempName); } if ($colors === false) { return $diff; } $diffLines = explode(PHP_EOL, $diff); if (count($diffLines) === 1) { // Seems to be required for cygwin. $diffLines = explode("\n", $diff); } $diff = []; foreach ($diffLines as $line) { if (isset($line[0]) === true) { switch ($line[0]) { case '-': $diff[] = "\033[31m$line\033[0m"; break; case '+': $diff[] = "\033[32m$line\033[0m"; break; default: $diff[] = $line; } } } $diff = implode(PHP_EOL, $diff); return $diff; }//end generateDiff() /** * Get a count of fixes that have been performed on the file. * * This value is reset every time a new file is started, or an existing * file is restarted. * * @return int */ public function getFixCount() { return $this->numFixes; }//end getFixCount() /** * Get the current content of the file, as a string. * * @return string */ public function getContents() { $contents = implode($this->tokens); return $contents; }//end getContents() /** * Get the current fixed content of a token. * * This function takes changesets into account so should be used * instead of directly accessing the token array. * * @param int $stackPtr The position of the token in the token stack. * * @return string */ public function getTokenContent($stackPtr) { if ($this->inChangeset === true && isset($this->changeset[$stackPtr]) === true ) { return $this->changeset[$stackPtr]; } else { return $this->tokens[$stackPtr]; } }//end getTokenContent() /** * Start recording actions for a changeset. * * @return void */ public function beginChangeset() { if ($this->inConflict === true) { return false; } if (PHP_CODESNIFFER_VERBOSITY > 1) { $bt = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS); if ($bt[1]['class'] === __CLASS__) { $sniff = 'Fixer'; } else { $sniff = Util\Common::getSniffCode($bt[1]['class']); } $line = $bt[0]['line']; @ob_end_clean(); echo "\t=> Changeset started by $sniff:$line".PHP_EOL; ob_start(); } $this->changeset = []; $this->inChangeset = true; }//end beginChangeset() /** * Stop recording actions for a changeset, and apply logged changes. * * @return boolean */ public function endChangeset() { if ($this->inConflict === true) { return false; } $this->inChangeset = false; $success = true; $applied = []; foreach ($this->changeset as $stackPtr => $content) { $success = $this->replaceToken($stackPtr, $content); if ($success === false) { break; } else { $applied[] = $stackPtr; } } if ($success === false) { // Rolling back all changes. foreach ($applied as $stackPtr) { $this->revertToken($stackPtr); } if (PHP_CODESNIFFER_VERBOSITY > 1) { @ob_end_clean(); echo "\t=> Changeset failed to apply".PHP_EOL; ob_start(); } } else if (PHP_CODESNIFFER_VERBOSITY > 1) { $fixes = count($this->changeset); @ob_end_clean(); echo "\t=> Changeset ended: $fixes changes applied".PHP_EOL; ob_start(); } $this->changeset = []; }//end endChangeset() /** * Stop recording actions for a changeset, and discard logged changes. * * @return void */ public function rollbackChangeset() { $this->inChangeset = false; $this->inConflict = false; if (empty($this->changeset) === false) { if (PHP_CODESNIFFER_VERBOSITY > 1) { $bt = debug_backtrace(); if ($bt[1]['class'] === 'PHP_CodeSniffer\Fixer') { $sniff = $bt[2]['class']; $line = $bt[1]['line']; } else { $sniff = $bt[1]['class']; $line = $bt[0]['line']; } $sniff = Util\Common::getSniffCode($sniff); $numChanges = count($this->changeset); @ob_end_clean(); echo "\t\tR: $sniff:$line rolled back the changeset ($numChanges changes)".PHP_EOL; echo "\t=> Changeset rolled back".PHP_EOL; ob_start(); } $this->changeset = []; }//end if }//end rollbackChangeset() /** * Replace the entire contents of a token. * * @param int $stackPtr The position of the token in the token stack. * @param string $content The new content of the token. * * @return bool If the change was accepted. */ public function replaceToken($stackPtr, $content) { if ($this->inConflict === true) { return false; } if ($this->inChangeset === false && isset($this->fixedTokens[$stackPtr]) === true ) { $indent = "\t"; if (empty($this->changeset) === false) { $indent .= "\t"; } if (PHP_CODESNIFFER_VERBOSITY > 1) { @ob_end_clean(); echo "$indent* token $stackPtr has already been modified, skipping *".PHP_EOL; ob_start(); } return false; } if (PHP_CODESNIFFER_VERBOSITY > 1) { $bt = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS); if ($bt[1]['class'] === 'PHP_CodeSniffer\Fixer') { $sniff = $bt[2]['class']; $line = $bt[1]['line']; } else { $sniff = $bt[1]['class']; $line = $bt[0]['line']; } $sniff = Util\Common::getSniffCode($sniff); $tokens = $this->currentFile->getTokens(); $type = $tokens[$stackPtr]['type']; $tokenLine = $tokens[$stackPtr]['line']; $oldContent = Common::prepareForOutput($this->tokens[$stackPtr]); $newContent = Common::prepareForOutput($content); if (trim($this->tokens[$stackPtr]) === '' && isset($this->tokens[($stackPtr + 1)]) === true) { // Add some context for whitespace only changes. $append = Common::prepareForOutput($this->tokens[($stackPtr + 1)]); $oldContent .= $append; $newContent .= $append; } }//end if if ($this->inChangeset === true) { $this->changeset[$stackPtr] = $content; if (PHP_CODESNIFFER_VERBOSITY > 1) { @ob_end_clean(); echo "\t\tQ: $sniff:$line replaced token $stackPtr ($type on line $tokenLine) \"$oldContent\" => \"$newContent\"".PHP_EOL; ob_start(); } return true; } if (isset($this->oldTokenValues[$stackPtr]) === false) { $this->oldTokenValues[$stackPtr] = [ 'curr' => $content, 'prev' => $this->tokens[$stackPtr], 'loop' => $this->loops, ]; } else { if ($this->oldTokenValues[$stackPtr]['prev'] === $content && $this->oldTokenValues[$stackPtr]['loop'] === ($this->loops - 1) ) { if (PHP_CODESNIFFER_VERBOSITY > 1) { $indent = "\t"; if (empty($this->changeset) === false) { $indent .= "\t"; } $loop = $this->oldTokenValues[$stackPtr]['loop']; @ob_end_clean(); echo "$indent**** $sniff:$line has possible conflict with another sniff on loop $loop; caused by the following change ****".PHP_EOL; echo "$indent**** replaced token $stackPtr ($type on line $tokenLine) \"$oldContent\" => \"$newContent\" ****".PHP_EOL; } if ($this->oldTokenValues[$stackPtr]['loop'] >= ($this->loops - 1)) { $this->inConflict = true; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo "$indent**** ignoring all changes until next loop ****".PHP_EOL; } } if (PHP_CODESNIFFER_VERBOSITY > 1) { ob_start(); } return false; }//end if $this->oldTokenValues[$stackPtr]['prev'] = $this->oldTokenValues[$stackPtr]['curr']; $this->oldTokenValues[$stackPtr]['curr'] = $content; $this->oldTokenValues[$stackPtr]['loop'] = $this->loops; }//end if $this->fixedTokens[$stackPtr] = $this->tokens[$stackPtr]; $this->tokens[$stackPtr] = $content; $this->numFixes++; if (PHP_CODESNIFFER_VERBOSITY > 1) { $indent = "\t"; if (empty($this->changeset) === false) { $indent .= "\tA: "; } if (ob_get_level() > 0) { ob_end_clean(); } echo "$indent$sniff:$line replaced token $stackPtr ($type on line $tokenLine) \"$oldContent\" => \"$newContent\"".PHP_EOL; ob_start(); } return true; }//end replaceToken() /** * Reverts the previous fix made to a token. * * @param int $stackPtr The position of the token in the token stack. * * @return bool If a change was reverted. */ public function revertToken($stackPtr) { if (isset($this->fixedTokens[$stackPtr]) === false) { return false; } if (PHP_CODESNIFFER_VERBOSITY > 1) { $bt = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS); if ($bt[1]['class'] === 'PHP_CodeSniffer\Fixer') { $sniff = $bt[2]['class']; $line = $bt[1]['line']; } else { $sniff = $bt[1]['class']; $line = $bt[0]['line']; } $sniff = Util\Common::getSniffCode($sniff); $tokens = $this->currentFile->getTokens(); $type = $tokens[$stackPtr]['type']; $tokenLine = $tokens[$stackPtr]['line']; $oldContent = Common::prepareForOutput($this->tokens[$stackPtr]); $newContent = Common::prepareForOutput($this->fixedTokens[$stackPtr]); if (trim($this->tokens[$stackPtr]) === '' && isset($tokens[($stackPtr + 1)]) === true) { // Add some context for whitespace only changes. $append = Common::prepareForOutput($this->tokens[($stackPtr + 1)]); $oldContent .= $append; $newContent .= $append; } }//end if $this->tokens[$stackPtr] = $this->fixedTokens[$stackPtr]; unset($this->fixedTokens[$stackPtr]); $this->numFixes--; if (PHP_CODESNIFFER_VERBOSITY > 1) { $indent = "\t"; if (empty($this->changeset) === false) { $indent .= "\tR: "; } @ob_end_clean(); echo "$indent$sniff:$line reverted token $stackPtr ($type on line $tokenLine) \"$oldContent\" => \"$newContent\"".PHP_EOL; ob_start(); } return true; }//end revertToken() /** * Replace the content of a token with a part of its current content. * * @param int $stackPtr The position of the token in the token stack. * @param int $start The first character to keep. * @param int $length The number of characters to keep. If NULL, the content of * the token from $start to the end of the content is kept. * * @return bool If the change was accepted. */ public function substrToken($stackPtr, $start, $length=null) { $current = $this->getTokenContent($stackPtr); if ($length === null) { $newContent = substr($current, $start); } else { $newContent = substr($current, $start, $length); } return $this->replaceToken($stackPtr, $newContent); }//end substrToken() /** * Adds a newline to end of a token's content. * * @param int $stackPtr The position of the token in the token stack. * * @return bool If the change was accepted. */ public function addNewline($stackPtr) { $current = $this->getTokenContent($stackPtr); return $this->replaceToken($stackPtr, $current.$this->currentFile->eolChar); }//end addNewline() /** * Adds a newline to the start of a token's content. * * @param int $stackPtr The position of the token in the token stack. * * @return bool If the change was accepted. */ public function addNewlineBefore($stackPtr) { $current = $this->getTokenContent($stackPtr); return $this->replaceToken($stackPtr, $this->currentFile->eolChar.$current); }//end addNewlineBefore() /** * Adds content to the end of a token's current content. * * @param int $stackPtr The position of the token in the token stack. * @param string $content The content to add. * * @return bool If the change was accepted. */ public function addContent($stackPtr, $content) { $current = $this->getTokenContent($stackPtr); return $this->replaceToken($stackPtr, $current.$content); }//end addContent() /** * Adds content to the start of a token's current content. * * @param int $stackPtr The position of the token in the token stack. * @param string $content The content to add. * * @return bool If the change was accepted. */ public function addContentBefore($stackPtr, $content) { $current = $this->getTokenContent($stackPtr); return $this->replaceToken($stackPtr, $content.$current); }//end addContentBefore() /** * Adjust the indent of a code block. * * @param int $start The position of the token in the token stack * to start adjusting the indent from. * @param int $end The position of the token in the token stack * to end adjusting the indent. * @param int $change The number of spaces to adjust the indent by * (positive or negative). * * @return bool If the change was accepted. */ public function changeCodeBlockIndent($start, $end, $change) { $tokens = $this->currentFile->getTokens(); $baseIndent = ''; if ($change > 0) { $baseIndent = str_repeat(' ', $change); } $useChangeset = false; if ($this->inChangeset === false) { $this->beginChangeset(); $useChangeset = true; } for ($i = $start; $i <= $end; $i++) { if ($tokens[$i]['column'] !== 1 || $tokens[($i + 1)]['line'] !== $tokens[$i]['line'] ) { continue; } $length = 0; if ($tokens[$i]['code'] === T_WHITESPACE || $tokens[$i]['code'] === T_DOC_COMMENT_WHITESPACE ) { $length = $tokens[$i]['length']; $padding = ($length + $change); if ($padding > 0) { $padding = str_repeat(' ', $padding); } else { $padding = ''; } $newContent = $padding.ltrim($tokens[$i]['content']); } else { $newContent = $baseIndent.$tokens[$i]['content']; } $this->replaceToken($i, $newContent); }//end for if ($useChangeset === true) { $this->endChangeset(); } }//end changeCodeBlockIndent() }//end class PHP_CodeSniffer-3.5.4/src/Reporter.php0000644000076500000240000003220513614652362017421 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer; use PHP_CodeSniffer\Exceptions\DeepExitException; use PHP_CodeSniffer\Exceptions\RuntimeException; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Reports\Report; use PHP_CodeSniffer\Util\Common; class Reporter { /** * The config data for the run. * * @var \PHP_CodeSniffer\Config */ public $config = null; /** * Total number of files that contain errors or warnings. * * @var integer */ public $totalFiles = 0; /** * Total number of errors found during the run. * * @var integer */ public $totalErrors = 0; /** * Total number of warnings found during the run. * * @var integer */ public $totalWarnings = 0; /** * Total number of errors/warnings that can be fixed. * * @var integer */ public $totalFixable = 0; /** * Total number of errors/warnings that were fixed. * * @var integer */ public $totalFixed = 0; /** * When the PHPCS run started. * * @var float */ public static $startTime = 0; /** * A cache of report objects. * * @var array */ private $reports = []; /** * A cache of opened temporary files. * * @var array */ private $tmpFiles = []; /** * Initialise the reporter. * * All reports specified in the config will be created and their * output file (or a temp file if none is specified) initialised by * clearing the current contents. * * @param \PHP_CodeSniffer\Config $config The config data for the run. * * @return void * @throws \PHP_CodeSniffer\Exceptions\DeepExitException If a custom report class could not be found. * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If a report class is incorrectly set up. */ public function __construct(Config $config) { $this->config = $config; foreach ($config->reports as $type => $output) { if ($output === null) { $output = $config->reportFile; } $reportClassName = ''; if (strpos($type, '.') !== false) { // This is a path to a custom report class. $filename = realpath($type); if ($filename === false) { $error = "ERROR: Custom report \"$type\" not found".PHP_EOL; throw new DeepExitException($error, 3); } $reportClassName = Autoload::loadFile($filename); } else if (class_exists('PHP_CodeSniffer\Reports\\'.ucfirst($type)) === true) { // PHPCS native report. $reportClassName = 'PHP_CodeSniffer\Reports\\'.ucfirst($type); } else if (class_exists($type) === true) { // FQN of a custom report. $reportClassName = $type; } else { // OK, so not a FQN, try and find the report using the registered namespaces. $registeredNamespaces = Autoload::getSearchPaths(); $trimmedType = ltrim($type, '\\'); foreach ($registeredNamespaces as $nsPrefix) { if ($nsPrefix === '') { continue; } if (class_exists($nsPrefix.'\\'.$trimmedType) === true) { $reportClassName = $nsPrefix.'\\'.$trimmedType; break; } } }//end if if ($reportClassName === '') { $error = "ERROR: Class file for report \"$type\" not found".PHP_EOL; throw new DeepExitException($error, 3); } $reportClass = new $reportClassName(); if (($reportClass instanceof Report) === false) { throw new RuntimeException('Class "'.$reportClassName.'" must implement the "PHP_CodeSniffer\Report" interface.'); } $this->reports[$type] = [ 'output' => $output, 'class' => $reportClass, ]; if ($output === null) { // Using a temp file. // This needs to be set in the constructor so that all // child procs use the same report file when running in parallel. $this->tmpFiles[$type] = tempnam(sys_get_temp_dir(), 'phpcs'); file_put_contents($this->tmpFiles[$type], ''); } else { file_put_contents($output, ''); } }//end foreach }//end __construct() /** * Generates and prints final versions of all reports. * * Returns TRUE if any of the reports output content to the screen * or FALSE if all reports were silently printed to a file. * * @return bool */ public function printReports() { $toScreen = false; foreach ($this->reports as $type => $report) { if ($report['output'] === null) { $toScreen = true; } $this->printReport($type); } return $toScreen; }//end printReports() /** * Generates and prints a single final report. * * @param string $report The report type to print. * * @return void */ public function printReport($report) { $reportClass = $this->reports[$report]['class']; $reportFile = $this->reports[$report]['output']; if ($reportFile !== null) { $filename = $reportFile; $toScreen = false; } else { if (isset($this->tmpFiles[$report]) === true) { $filename = $this->tmpFiles[$report]; } else { $filename = null; } $toScreen = true; } $reportCache = ''; if ($filename !== null) { $reportCache = file_get_contents($filename); } ob_start(); $reportClass->generate( $reportCache, $this->totalFiles, $this->totalErrors, $this->totalWarnings, $this->totalFixable, $this->config->showSources, $this->config->reportWidth, $this->config->interactive, $toScreen ); $generatedReport = ob_get_contents(); ob_end_clean(); if ($this->config->colors !== true || $reportFile !== null) { $generatedReport = preg_replace('`\033\[[0-9;]+m`', '', $generatedReport); } if ($reportFile !== null) { if (PHP_CODESNIFFER_VERBOSITY > 0) { echo $generatedReport; } file_put_contents($reportFile, $generatedReport.PHP_EOL); } else { echo $generatedReport; if ($filename !== null && file_exists($filename) === true) { unlink($filename); unset($this->tmpFiles[$report]); } } }//end printReport() /** * Caches the result of a single processed file for all reports. * * The report content that is generated is appended to the output file * assigned to each report. This content may be an intermediate report format * and not reflect the final report output. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file that has been processed. * * @return void */ public function cacheFileReport(File $phpcsFile) { if (isset($this->config->reports) === false) { // This happens during unit testing, or any time someone just wants // the error data and not the printed report. return; } $reportData = $this->prepareFileReport($phpcsFile); $errorsShown = false; foreach ($this->reports as $type => $report) { $reportClass = $report['class']; ob_start(); $result = $reportClass->generateFileReport($reportData, $phpcsFile, $this->config->showSources, $this->config->reportWidth); if ($result === true) { $errorsShown = true; } $generatedReport = ob_get_contents(); ob_end_clean(); if ($report['output'] === null) { // Using a temp file. if (isset($this->tmpFiles[$type]) === false) { // When running in interactive mode, the reporter prints the full // report many times, which will unlink the temp file. So we need // to create a new one if it doesn't exist. $this->tmpFiles[$type] = tempnam(sys_get_temp_dir(), 'phpcs'); file_put_contents($this->tmpFiles[$type], ''); } file_put_contents($this->tmpFiles[$type], $generatedReport, (FILE_APPEND | LOCK_EX)); } else { file_put_contents($report['output'], $generatedReport, (FILE_APPEND | LOCK_EX)); }//end if }//end foreach if ($errorsShown === true || PHP_CODESNIFFER_CBF === true) { $this->totalFiles++; $this->totalErrors += $reportData['errors']; $this->totalWarnings += $reportData['warnings']; // When PHPCBF is running, we need to use the fixable error values // after the report has run and fixed what it can. if (PHP_CODESNIFFER_CBF === true) { $this->totalFixable += $phpcsFile->getFixableCount(); $this->totalFixed += $phpcsFile->getFixedCount(); } else { $this->totalFixable += $reportData['fixable']; } } }//end cacheFileReport() /** * Generate summary information to be used during report generation. * * @param \PHP_CodeSniffer\Files\File $phpcsFile The file that has been processed. * * @return array */ public function prepareFileReport(File $phpcsFile) { $report = [ 'filename' => Common::stripBasepath($phpcsFile->getFilename(), $this->config->basepath), 'errors' => $phpcsFile->getErrorCount(), 'warnings' => $phpcsFile->getWarningCount(), 'fixable' => $phpcsFile->getFixableCount(), 'messages' => [], ]; if ($report['errors'] === 0 && $report['warnings'] === 0) { // Prefect score! return $report; } if ($this->config->recordErrors === false) { $message = 'Errors are not being recorded but this report requires error messages. '; $message .= 'This report will not show the correct information.'; $report['messages'][1][1] = [ [ 'message' => $message, 'source' => 'Internal.RecordErrors', 'severity' => 5, 'fixable' => false, 'type' => 'ERROR', ], ]; return $report; } $errors = []; // Merge errors and warnings. foreach ($phpcsFile->getErrors() as $line => $lineErrors) { foreach ($lineErrors as $column => $colErrors) { $newErrors = []; foreach ($colErrors as $data) { $newErrors[] = [ 'message' => $data['message'], 'source' => $data['source'], 'severity' => $data['severity'], 'fixable' => $data['fixable'], 'type' => 'ERROR', ]; } $errors[$line][$column] = $newErrors; } ksort($errors[$line]); }//end foreach foreach ($phpcsFile->getWarnings() as $line => $lineWarnings) { foreach ($lineWarnings as $column => $colWarnings) { $newWarnings = []; foreach ($colWarnings as $data) { $newWarnings[] = [ 'message' => $data['message'], 'source' => $data['source'], 'severity' => $data['severity'], 'fixable' => $data['fixable'], 'type' => 'WARNING', ]; } if (isset($errors[$line]) === false) { $errors[$line] = []; } if (isset($errors[$line][$column]) === true) { $errors[$line][$column] = array_merge( $newWarnings, $errors[$line][$column] ); } else { $errors[$line][$column] = $newWarnings; } }//end foreach ksort($errors[$line]); }//end foreach ksort($errors); $report['messages'] = $errors; return $report; }//end prepareFileReport() }//end class PHP_CodeSniffer-3.5.4/src/Ruleset.php0000644000076500000240000014303613614652362017247 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer; use PHP_CodeSniffer\Exceptions\RuntimeException; use PHP_CodeSniffer\Util; class Ruleset { /** * The name of the coding standard being used. * * If a top-level standard includes other standards, or sniffs * from other standards, only the name of the top-level standard * will be stored in here. * * If multiple top-level standards are being loaded into * a single ruleset object, this will store a comma separated list * of the top-level standard names. * * @var string */ public $name = ''; /** * A list of file paths for the ruleset files being used. * * @var string[] */ public $paths = []; /** * A list of regular expressions used to ignore specific sniffs for files and folders. * * Is also used to set global exclude patterns. * The key is the regular expression and the value is the type * of ignore pattern (absolute or relative). * * @var array */ public $ignorePatterns = []; /** * A list of regular expressions used to include specific sniffs for files and folders. * * The key is the sniff code and the value is an array with * the key being a regular expression and the value is the type * of ignore pattern (absolute or relative). * * @var array> */ public $includePatterns = []; /** * An array of sniff objects that are being used to check files. * * The key is the fully qualified name of the sniff class * and the value is the sniff object. * * @var array */ public $sniffs = []; /** * A mapping of sniff codes to fully qualified class names. * * The key is the sniff code and the value * is the fully qualified name of the sniff class. * * @var array */ public $sniffCodes = []; /** * An array of token types and the sniffs that are listening for them. * * The key is the token name being listened for and the value * is the sniff object. * * @var array */ public $tokenListeners = []; /** * An array of rules from the ruleset.xml file. * * It may be empty, indicating that the ruleset does not override * any of the default sniff settings. * * @var array */ public $ruleset = []; /** * The directories that the processed rulesets are in. * * @var string[] */ protected $rulesetDirs = []; /** * The config data for the run. * * @var \PHP_CodeSniffer\Config */ private $config = null; /** * Initialise the ruleset that the run will use. * * @param \PHP_CodeSniffer\Config $config The config data for the run. * * @return void * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If no sniffs were registered. */ public function __construct(Config $config) { // Ignore sniff restrictions if caching is on. $restrictions = []; $exclusions = []; if ($config->cache === false) { $restrictions = $config->sniffs; $exclusions = $config->exclude; } $this->config = $config; $sniffs = []; $standardPaths = []; foreach ($config->standards as $standard) { $installed = Util\Standards::getInstalledStandardPath($standard); if ($installed === null) { $standard = Util\Common::realpath($standard); if (is_dir($standard) === true && is_file(Util\Common::realpath($standard.DIRECTORY_SEPARATOR.'ruleset.xml')) === true ) { $standard = Util\Common::realpath($standard.DIRECTORY_SEPARATOR.'ruleset.xml'); } } else { $standard = $installed; } $standardPaths[] = $standard; } foreach ($standardPaths as $standard) { $ruleset = @simplexml_load_string(file_get_contents($standard)); if ($ruleset !== false) { $standardName = (string) $ruleset['name']; if ($this->name !== '') { $this->name .= ', '; } $this->name .= $standardName; // Allow autoloading of custom files inside this standard. if (isset($ruleset['namespace']) === true) { $namespace = (string) $ruleset['namespace']; } else { $namespace = basename(dirname($standard)); } Autoload::addSearchPath(dirname($standard), $namespace); } if (defined('PHP_CODESNIFFER_IN_TESTS') === true && empty($restrictions) === false) { // In unit tests, only register the sniffs that the test wants and not the entire standard. try { foreach ($restrictions as $restriction) { $sniffs = array_merge($sniffs, $this->expandRulesetReference($restriction, dirname($standard))); } } catch (RuntimeException $e) { // Sniff reference could not be expanded, which probably means this // is an installed standard. Let the unit test system take care of // setting the correct sniff for testing. return; } break; } if (PHP_CODESNIFFER_VERBOSITY === 1) { echo "Registering sniffs in the $standardName standard... "; if (count($config->standards) > 1 || PHP_CODESNIFFER_VERBOSITY > 2) { echo PHP_EOL; } } $sniffs = array_merge($sniffs, $this->processRuleset($standard)); }//end foreach $sniffRestrictions = []; foreach ($restrictions as $sniffCode) { $parts = explode('.', strtolower($sniffCode)); $sniffName = $parts[0].'\sniffs\\'.$parts[1].'\\'.$parts[2].'sniff'; $sniffRestrictions[$sniffName] = true; } $sniffExclusions = []; foreach ($exclusions as $sniffCode) { $parts = explode('.', strtolower($sniffCode)); $sniffName = $parts[0].'\sniffs\\'.$parts[1].'\\'.$parts[2].'sniff'; $sniffExclusions[$sniffName] = true; } $this->registerSniffs($sniffs, $sniffRestrictions, $sniffExclusions); $this->populateTokenListeners(); $numSniffs = count($this->sniffs); if (PHP_CODESNIFFER_VERBOSITY === 1) { echo "DONE ($numSniffs sniffs registered)".PHP_EOL; } if ($numSniffs === 0) { throw new RuntimeException('No sniffs were registered'); } }//end __construct() /** * Prints a report showing the sniffs contained in a standard. * * @return void */ public function explain() { $sniffs = array_keys($this->sniffCodes); sort($sniffs); ob_start(); $lastStandard = null; $lastCount = ''; $sniffCount = count($sniffs); // Add a dummy entry to the end so we loop // one last time and clear the output buffer. $sniffs[] = ''; echo PHP_EOL."The $this->name standard contains $sniffCount sniffs".PHP_EOL; ob_start(); foreach ($sniffs as $i => $sniff) { if ($i === $sniffCount) { $currentStandard = null; } else { $currentStandard = substr($sniff, 0, strpos($sniff, '.')); if ($lastStandard === null) { $lastStandard = $currentStandard; } } if ($currentStandard !== $lastStandard) { $sniffList = ob_get_contents(); ob_end_clean(); echo PHP_EOL.$lastStandard.' ('.$lastCount.' sniff'; if ($lastCount > 1) { echo 's'; } echo ')'.PHP_EOL; echo str_repeat('-', (strlen($lastStandard.$lastCount) + 10)); echo PHP_EOL; echo $sniffList; $lastStandard = $currentStandard; $lastCount = 0; if ($currentStandard === null) { break; } ob_start(); }//end if echo ' '.$sniff.PHP_EOL; $lastCount++; }//end foreach }//end explain() /** * Processes a single ruleset and returns a list of the sniffs it represents. * * Rules founds within the ruleset are processed immediately, but sniff classes * are not registered by this method. * * @param string $rulesetPath The path to a ruleset XML file. * @param int $depth How many nested processing steps we are in. This * is only used for debug output. * * @return string[] * @throws \PHP_CodeSniffer\Exceptions\RuntimeException - If the ruleset path is invalid. * - If a specified autoload file could not be found. */ public function processRuleset($rulesetPath, $depth=0) { $rulesetPath = Util\Common::realpath($rulesetPath); if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo 'Processing ruleset '.Util\Common::stripBasepath($rulesetPath, $this->config->basepath).PHP_EOL; } libxml_use_internal_errors(true); $ruleset = simplexml_load_string(file_get_contents($rulesetPath)); if ($ruleset === false) { $errorMsg = "Ruleset $rulesetPath is not valid".PHP_EOL; $errors = libxml_get_errors(); foreach ($errors as $error) { $errorMsg .= '- On line '.$error->line.', column '.$error->column.': '.$error->message; } libxml_clear_errors(); throw new RuntimeException($errorMsg); } libxml_use_internal_errors(false); $ownSniffs = []; $includedSniffs = []; $excludedSniffs = []; $this->paths[] = $rulesetPath; $rulesetDir = dirname($rulesetPath); $this->rulesetDirs[] = $rulesetDir; $sniffDir = $rulesetDir.DIRECTORY_SEPARATOR.'Sniffs'; if (is_dir($sniffDir) === true) { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\tAdding sniff files from ".Util\Common::stripBasepath($sniffDir, $this->config->basepath).' directory'.PHP_EOL; } $ownSniffs = $this->expandSniffDirectory($sniffDir, $depth); } // Include custom autoloaders. foreach ($ruleset->{'autoload'} as $autoload) { if ($this->shouldProcessElement($autoload) === false) { continue; } $autoloadPath = (string) $autoload; // Try relative autoload paths first. $relativePath = Util\Common::realPath(dirname($rulesetPath).DIRECTORY_SEPARATOR.$autoloadPath); if ($relativePath !== false && is_file($relativePath) === true) { $autoloadPath = $relativePath; } else if (is_file($autoloadPath) === false) { throw new RuntimeException('The specified autoload file "'.$autoload.'" does not exist'); } include_once $autoloadPath; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t=> included autoloader $autoloadPath".PHP_EOL; } }//end foreach // Process custom sniff config settings. foreach ($ruleset->{'config'} as $config) { if ($this->shouldProcessElement($config) === false) { continue; } Config::setConfigData((string) $config['name'], (string) $config['value'], true); if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t=> set config value ".(string) $config['name'].': '.(string) $config['value'].PHP_EOL; } } foreach ($ruleset->rule as $rule) { if (isset($rule['ref']) === false || $this->shouldProcessElement($rule) === false ) { continue; } if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\tProcessing rule \"".$rule['ref'].'"'.PHP_EOL; } $expandedSniffs = $this->expandRulesetReference((string) $rule['ref'], $rulesetDir, $depth); $newSniffs = array_diff($expandedSniffs, $includedSniffs); $includedSniffs = array_merge($includedSniffs, $expandedSniffs); $parts = explode('.', $rule['ref']); if (count($parts) === 4 && $parts[0] !== '' && $parts[1] !== '' && $parts[2] !== '' ) { $sniffCode = $parts[0].'.'.$parts[1].'.'.$parts[2]; if (isset($this->ruleset[$sniffCode]['severity']) === true && $this->ruleset[$sniffCode]['severity'] === 0 ) { // This sniff code has already been turned off, but now // it is being explicitly included again, so turn it back on. $this->ruleset[(string) $rule['ref']]['severity'] = 5; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t\t* disabling sniff exclusion for specific message code *".PHP_EOL; echo str_repeat("\t", $depth); echo "\t\t=> severity set to 5".PHP_EOL; } } else if (empty($newSniffs) === false) { $newSniff = $newSniffs[0]; if (in_array($newSniff, $ownSniffs, true) === false) { // Including a sniff that hasn't been included higher up, but // only including a single message from it. So turn off all messages in // the sniff, except this one. $this->ruleset[$sniffCode]['severity'] = 0; $this->ruleset[(string) $rule['ref']]['severity'] = 5; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t\tExcluding sniff \"".$sniffCode.'" except for "'.$parts[3].'"'.PHP_EOL; } } }//end if }//end if if (isset($rule->exclude) === true) { foreach ($rule->exclude as $exclude) { if (isset($exclude['name']) === false) { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t\t* ignoring empty exclude rule *".PHP_EOL; echo "\t\t\t=> ".$exclude->asXML().PHP_EOL; } continue; } if ($this->shouldProcessElement($exclude) === false) { continue; } if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t\tExcluding rule \"".$exclude['name'].'"'.PHP_EOL; } // Check if a single code is being excluded, which is a shortcut // for setting the severity of the message to 0. $parts = explode('.', $exclude['name']); if (count($parts) === 4) { $this->ruleset[(string) $exclude['name']]['severity'] = 0; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t\t=> severity set to 0".PHP_EOL; } } else { $excludedSniffs = array_merge( $excludedSniffs, $this->expandRulesetReference((string) $exclude['name'], $rulesetDir, ($depth + 1)) ); } }//end foreach }//end if $this->processRule($rule, $newSniffs, $depth); }//end foreach // Process custom command line arguments. $cliArgs = []; foreach ($ruleset->{'arg'} as $arg) { if ($this->shouldProcessElement($arg) === false) { continue; } if (isset($arg['name']) === true) { $argString = '--'.(string) $arg['name']; if (isset($arg['value']) === true) { $argString .= '='.(string) $arg['value']; } } else { $argString = '-'.(string) $arg['value']; } $cliArgs[] = $argString; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t=> set command line value $argString".PHP_EOL; } }//end foreach // Set custom php ini values as CLI args. foreach ($ruleset->{'ini'} as $arg) { if ($this->shouldProcessElement($arg) === false) { continue; } if (isset($arg['name']) === false) { continue; } $name = (string) $arg['name']; $argString = $name; if (isset($arg['value']) === true) { $value = (string) $arg['value']; $argString .= "=$value"; } else { $value = 'true'; } $cliArgs[] = '-d'; $cliArgs[] = $argString; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t=> set PHP ini value $name to $value".PHP_EOL; } }//end foreach if (empty($this->config->files) === true) { // Process hard-coded file paths. foreach ($ruleset->{'file'} as $file) { $file = (string) $file; $cliArgs[] = $file; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t=> added \"$file\" to the file list".PHP_EOL; } } } if (empty($cliArgs) === false) { // Change the directory so all relative paths are worked // out based on the location of the ruleset instead of // the location of the user. $inPhar = Util\Common::isPharFile($rulesetDir); if ($inPhar === false) { $currentDir = getcwd(); chdir($rulesetDir); } $this->config->setCommandLineValues($cliArgs); if ($inPhar === false) { chdir($currentDir); } } // Process custom ignore pattern rules. foreach ($ruleset->{'exclude-pattern'} as $pattern) { if ($this->shouldProcessElement($pattern) === false) { continue; } if (isset($pattern['type']) === false) { $pattern['type'] = 'absolute'; } $this->ignorePatterns[(string) $pattern] = (string) $pattern['type']; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t=> added global ".(string) $pattern['type'].' ignore pattern: '.(string) $pattern.PHP_EOL; } } $includedSniffs = array_unique(array_merge($ownSniffs, $includedSniffs)); $excludedSniffs = array_unique($excludedSniffs); if (PHP_CODESNIFFER_VERBOSITY > 1) { $included = count($includedSniffs); $excluded = count($excludedSniffs); echo str_repeat("\t", $depth); echo "=> Ruleset processing complete; included $included sniffs and excluded $excluded".PHP_EOL; } // Merge our own sniff list with our externally included // sniff list, but filter out any excluded sniffs. $files = []; foreach ($includedSniffs as $sniff) { if (in_array($sniff, $excludedSniffs, true) === true) { continue; } else { $files[] = Util\Common::realpath($sniff); } } return $files; }//end processRuleset() /** * Expands a directory into a list of sniff files within. * * @param string $directory The path to a directory. * @param int $depth How many nested processing steps we are in. This * is only used for debug output. * * @return array */ private function expandSniffDirectory($directory, $depth=0) { $sniffs = []; $rdi = new \RecursiveDirectoryIterator($directory, \RecursiveDirectoryIterator::FOLLOW_SYMLINKS); $di = new \RecursiveIteratorIterator($rdi, 0, \RecursiveIteratorIterator::CATCH_GET_CHILD); $dirLen = strlen($directory); foreach ($di as $file) { $filename = $file->getFilename(); // Skip hidden files. if (substr($filename, 0, 1) === '.') { continue; } // We are only interested in PHP and sniff files. $fileParts = explode('.', $filename); if (array_pop($fileParts) !== 'php') { continue; } $basename = basename($filename, '.php'); if (substr($basename, -5) !== 'Sniff') { continue; } $path = $file->getPathname(); // Skip files in hidden directories within the Sniffs directory of this // standard. We use the offset with strpos() to allow hidden directories // before, valid example: // /home/foo/.composer/vendor/squiz/custom_tool/MyStandard/Sniffs/... if (strpos($path, DIRECTORY_SEPARATOR.'.', $dirLen) !== false) { continue; } if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t\t=> ".Util\Common::stripBasepath($path, $this->config->basepath).PHP_EOL; } $sniffs[] = $path; }//end foreach return $sniffs; }//end expandSniffDirectory() /** * Expands a ruleset reference into a list of sniff files. * * @param string $ref The reference from the ruleset XML file. * @param string $rulesetDir The directory of the ruleset XML file, used to * evaluate relative paths. * @param int $depth How many nested processing steps we are in. This * is only used for debug output. * * @return array * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If the reference is invalid. */ private function expandRulesetReference($ref, $rulesetDir, $depth=0) { // Ignore internal sniffs codes as they are used to only // hide and change internal messages. if (substr($ref, 0, 9) === 'Internal.') { if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t\t* ignoring internal sniff code *".PHP_EOL; } return []; } // As sniffs can't begin with a full stop, assume references in // this format are relative paths and attempt to convert them // to absolute paths. If this fails, let the reference run through // the normal checks and have it fail as normal. if (substr($ref, 0, 1) === '.') { $realpath = Util\Common::realpath($rulesetDir.'/'.$ref); if ($realpath !== false) { $ref = $realpath; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t\t=> ".Util\Common::stripBasepath($ref, $this->config->basepath).PHP_EOL; } } } // As sniffs can't begin with a tilde, assume references in // this format are relative to the user's home directory. if (substr($ref, 0, 2) === '~/') { $realpath = Util\Common::realpath($ref); if ($realpath !== false) { $ref = $realpath; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t\t=> ".Util\Common::stripBasepath($ref, $this->config->basepath).PHP_EOL; } } } if (is_file($ref) === true) { if (substr($ref, -9) === 'Sniff.php') { // A single external sniff. $this->rulesetDirs[] = dirname(dirname(dirname($ref))); return [$ref]; } } else { // See if this is a whole standard being referenced. $path = Util\Standards::getInstalledStandardPath($ref); if (Util\Common::isPharFile($path) === true && strpos($path, 'ruleset.xml') === false) { // If the ruleset exists inside the phar file, use it. if (file_exists($path.DIRECTORY_SEPARATOR.'ruleset.xml') === true) { $path .= DIRECTORY_SEPARATOR.'ruleset.xml'; } else { $path = null; } } if ($path !== null) { $ref = $path; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t\t=> ".Util\Common::stripBasepath($ref, $this->config->basepath).PHP_EOL; } } else if (is_dir($ref) === false) { // Work out the sniff path. $sepPos = strpos($ref, DIRECTORY_SEPARATOR); if ($sepPos !== false) { $stdName = substr($ref, 0, $sepPos); $path = substr($ref, $sepPos); } else { $parts = explode('.', $ref); $stdName = $parts[0]; if (count($parts) === 1) { // A whole standard? $path = ''; } else if (count($parts) === 2) { // A directory of sniffs? $path = DIRECTORY_SEPARATOR.'Sniffs'.DIRECTORY_SEPARATOR.$parts[1]; } else { // A single sniff? $path = DIRECTORY_SEPARATOR.'Sniffs'.DIRECTORY_SEPARATOR.$parts[1].DIRECTORY_SEPARATOR.$parts[2].'Sniff.php'; } } $newRef = false; $stdPath = Util\Standards::getInstalledStandardPath($stdName); if ($stdPath !== null && $path !== '') { if (Util\Common::isPharFile($stdPath) === true && strpos($stdPath, 'ruleset.xml') === false ) { // Phar files can only return the directory, // since ruleset can be omitted if building one standard. $newRef = Util\Common::realpath($stdPath.$path); } else { $newRef = Util\Common::realpath(dirname($stdPath).$path); } } if ($newRef === false) { // The sniff is not locally installed, so check if it is being // referenced as a remote sniff outside the install. We do this // by looking through all directories where we have found ruleset // files before, looking for ones for this particular standard, // and seeing if it is in there. foreach ($this->rulesetDirs as $dir) { if (strtolower(basename($dir)) !== strtolower($stdName)) { continue; } $newRef = Util\Common::realpath($dir.$path); if ($newRef !== false) { $ref = $newRef; } } } else { $ref = $newRef; } if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t\t=> ".Util\Common::stripBasepath($ref, $this->config->basepath).PHP_EOL; } }//end if }//end if if (is_dir($ref) === true) { if (is_file($ref.DIRECTORY_SEPARATOR.'ruleset.xml') === true) { // We are referencing an external coding standard. if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t\t* rule is referencing a standard using directory name; processing *".PHP_EOL; } return $this->processRuleset($ref.DIRECTORY_SEPARATOR.'ruleset.xml', ($depth + 2)); } else { // We are referencing a whole directory of sniffs. if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t\t* rule is referencing a directory of sniffs *".PHP_EOL; echo str_repeat("\t", $depth); echo "\t\tAdding sniff files from directory".PHP_EOL; } return $this->expandSniffDirectory($ref, ($depth + 1)); } } else { if (is_file($ref) === false) { $error = "Referenced sniff \"$ref\" does not exist"; throw new RuntimeException($error); } if (substr($ref, -9) === 'Sniff.php') { // A single sniff. return [$ref]; } else { // Assume an external ruleset.xml file. if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t\t* rule is referencing a standard using ruleset path; processing *".PHP_EOL; } return $this->processRuleset($ref, ($depth + 2)); } }//end if }//end expandRulesetReference() /** * Processes a rule from a ruleset XML file, overriding built-in defaults. * * @param \SimpleXMLElement $rule The rule object from a ruleset XML file. * @param string[] $newSniffs An array of sniffs that got included by this rule. * @param int $depth How many nested processing steps we are in. * This is only used for debug output. * * @return void * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If rule settings are invalid. */ private function processRule($rule, $newSniffs, $depth=0) { $ref = (string) $rule['ref']; $todo = [$ref]; $parts = explode('.', $ref); $partsCount = count($parts); if ($partsCount <= 2 || $partsCount > count(array_filter($parts))) { // We are processing a standard, a category of sniffs or a relative path inclusion. foreach ($newSniffs as $sniffFile) { $parts = explode(DIRECTORY_SEPARATOR, $sniffFile); if (count($parts) === 1 && DIRECTORY_SEPARATOR === '\\') { // Path using forward slashes while running on Windows. $parts = explode('/', $sniffFile); } $sniffName = array_pop($parts); $sniffCategory = array_pop($parts); array_pop($parts); $sniffStandard = array_pop($parts); $todo[] = $sniffStandard.'.'.$sniffCategory.'.'.substr($sniffName, 0, -9); } } foreach ($todo as $code) { // Custom severity. if (isset($rule->severity) === true && $this->shouldProcessElement($rule->severity) === true ) { if (isset($this->ruleset[$code]) === false) { $this->ruleset[$code] = []; } $this->ruleset[$code]['severity'] = (int) $rule->severity; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t\t=> severity set to ".(int) $rule->severity; if ($code !== $ref) { echo " for $code"; } echo PHP_EOL; } } // Custom message type. if (isset($rule->type) === true && $this->shouldProcessElement($rule->type) === true ) { if (isset($this->ruleset[$code]) === false) { $this->ruleset[$code] = []; } $type = strtolower((string) $rule->type); if ($type !== 'error' && $type !== 'warning') { throw new RuntimeException("Message type \"$type\" is invalid; must be \"error\" or \"warning\""); } $this->ruleset[$code]['type'] = $type; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t\t=> message type set to ".(string) $rule->type; if ($code !== $ref) { echo " for $code"; } echo PHP_EOL; } }//end if // Custom message. if (isset($rule->message) === true && $this->shouldProcessElement($rule->message) === true ) { if (isset($this->ruleset[$code]) === false) { $this->ruleset[$code] = []; } $this->ruleset[$code]['message'] = (string) $rule->message; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t\t=> message set to ".(string) $rule->message; if ($code !== $ref) { echo " for $code"; } echo PHP_EOL; } } // Custom properties. if (isset($rule->properties) === true && $this->shouldProcessElement($rule->properties) === true ) { foreach ($rule->properties->property as $prop) { if ($this->shouldProcessElement($prop) === false) { continue; } if (isset($this->ruleset[$code]) === false) { $this->ruleset[$code] = [ 'properties' => [], ]; } else if (isset($this->ruleset[$code]['properties']) === false) { $this->ruleset[$code]['properties'] = []; } $name = (string) $prop['name']; if (isset($prop['type']) === true && (string) $prop['type'] === 'array' ) { $values = []; if (isset($prop['extend']) === true && (string) $prop['extend'] === 'true' && isset($this->ruleset[$code]['properties'][$name]) === true ) { $values = $this->ruleset[$code]['properties'][$name]; } if (isset($prop->element) === true) { $printValue = ''; foreach ($prop->element as $element) { if ($this->shouldProcessElement($element) === false) { continue; } $value = (string) $element['value']; if (isset($element['key']) === true) { $key = (string) $element['key']; $values[$key] = $value; $printValue .= $key.'=>'.$value.','; } else { $values[] = $value; $printValue .= $value.','; } } $printValue = rtrim($printValue, ','); } else { $value = (string) $prop['value']; $printValue = $value; foreach (explode(',', $value) as $val) { list($k, $v) = explode('=>', $val.'=>'); if ($v !== '') { $values[trim($k)] = trim($v); } else { $values[] = trim($k); } } }//end if $this->ruleset[$code]['properties'][$name] = $values; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t\t=> array property \"$name\" set to \"$printValue\""; if ($code !== $ref) { echo " for $code"; } echo PHP_EOL; } } else { $this->ruleset[$code]['properties'][$name] = (string) $prop['value']; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t\t=> property \"$name\" set to \"".(string) $prop['value'].'"'; if ($code !== $ref) { echo " for $code"; } echo PHP_EOL; } }//end if }//end foreach }//end if // Ignore patterns. foreach ($rule->{'exclude-pattern'} as $pattern) { if ($this->shouldProcessElement($pattern) === false) { continue; } if (isset($this->ignorePatterns[$code]) === false) { $this->ignorePatterns[$code] = []; } if (isset($pattern['type']) === false) { $pattern['type'] = 'absolute'; } $this->ignorePatterns[$code][(string) $pattern] = (string) $pattern['type']; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t\t=> added rule-specific ".(string) $pattern['type'].' ignore pattern'; if ($code !== $ref) { echo " for $code"; } echo ': '.(string) $pattern.PHP_EOL; } }//end foreach // Include patterns. foreach ($rule->{'include-pattern'} as $pattern) { if ($this->shouldProcessElement($pattern) === false) { continue; } if (isset($this->includePatterns[$code]) === false) { $this->includePatterns[$code] = []; } if (isset($pattern['type']) === false) { $pattern['type'] = 'absolute'; } $this->includePatterns[$code][(string) $pattern] = (string) $pattern['type']; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo str_repeat("\t", $depth); echo "\t\t=> added rule-specific ".(string) $pattern['type'].' include pattern'; if ($code !== $ref) { echo " for $code"; } echo ': '.(string) $pattern.PHP_EOL; } }//end foreach }//end foreach }//end processRule() /** * Determine if an element should be processed or ignored. * * @param \SimpleXMLElement $element An object from a ruleset XML file. * * @return bool */ private function shouldProcessElement($element) { if (isset($element['phpcbf-only']) === false && isset($element['phpcs-only']) === false ) { // No exceptions are being made. return true; } if (PHP_CODESNIFFER_CBF === true && isset($element['phpcbf-only']) === true && (string) $element['phpcbf-only'] === 'true' ) { return true; } if (PHP_CODESNIFFER_CBF === false && isset($element['phpcs-only']) === true && (string) $element['phpcs-only'] === 'true' ) { return true; } return false; }//end shouldProcessElement() /** * Loads and stores sniffs objects used for sniffing files. * * @param array $files Paths to the sniff files to register. * @param array $restrictions The sniff class names to restrict the allowed * listeners to. * @param array $exclusions The sniff class names to exclude from the * listeners list. * * @return void */ public function registerSniffs($files, $restrictions, $exclusions) { $listeners = []; foreach ($files as $file) { // Work out where the position of /StandardName/Sniffs/... is // so we can determine what the class will be called. $sniffPos = strrpos($file, DIRECTORY_SEPARATOR.'Sniffs'.DIRECTORY_SEPARATOR); if ($sniffPos === false) { continue; } $slashPos = strrpos(substr($file, 0, $sniffPos), DIRECTORY_SEPARATOR); if ($slashPos === false) { continue; } $className = Autoload::loadFile($file); $compareName = Util\Common::cleanSniffClass($className); // If they have specified a list of sniffs to restrict to, check // to see if this sniff is allowed. if (empty($restrictions) === false && isset($restrictions[$compareName]) === false ) { continue; } // If they have specified a list of sniffs to exclude, check // to see if this sniff is allowed. if (empty($exclusions) === false && isset($exclusions[$compareName]) === true ) { continue; } // Skip abstract classes. $reflection = new \ReflectionClass($className); if ($reflection->isAbstract() === true) { continue; } $listeners[$className] = $className; if (PHP_CODESNIFFER_VERBOSITY > 2) { echo "Registered $className".PHP_EOL; } }//end foreach $this->sniffs = $listeners; }//end registerSniffs() /** * Populates the array of PHP_CodeSniffer_Sniff objects for this file. * * @return void * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If sniff registration fails. */ public function populateTokenListeners() { // Construct a list of listeners indexed by token being listened for. $this->tokenListeners = []; foreach ($this->sniffs as $sniffClass => $sniffObject) { $this->sniffs[$sniffClass] = null; $this->sniffs[$sniffClass] = new $sniffClass(); $sniffCode = Util\Common::getSniffCode($sniffClass); $this->sniffCodes[$sniffCode] = $sniffClass; // Set custom properties. if (isset($this->ruleset[$sniffCode]['properties']) === true) { foreach ($this->ruleset[$sniffCode]['properties'] as $name => $value) { $this->setSniffProperty($sniffClass, $name, $value); } } $tokenizers = []; $vars = get_class_vars($sniffClass); if (isset($vars['supportedTokenizers']) === true) { foreach ($vars['supportedTokenizers'] as $tokenizer) { $tokenizers[$tokenizer] = $tokenizer; } } else { $tokenizers = ['PHP' => 'PHP']; } $tokens = $this->sniffs[$sniffClass]->register(); if (is_array($tokens) === false) { $msg = "Sniff $sniffClass register() method must return an array"; throw new RuntimeException($msg); } $ignorePatterns = []; $patterns = $this->getIgnorePatterns($sniffCode); foreach ($patterns as $pattern => $type) { $replacements = [ '\\,' => ',', '*' => '.*', ]; $ignorePatterns[] = strtr($pattern, $replacements); } $includePatterns = []; $patterns = $this->getIncludePatterns($sniffCode); foreach ($patterns as $pattern => $type) { $replacements = [ '\\,' => ',', '*' => '.*', ]; $includePatterns[] = strtr($pattern, $replacements); } foreach ($tokens as $token) { if (isset($this->tokenListeners[$token]) === false) { $this->tokenListeners[$token] = []; } if (isset($this->tokenListeners[$token][$sniffClass]) === false) { $this->tokenListeners[$token][$sniffClass] = [ 'class' => $sniffClass, 'source' => $sniffCode, 'tokenizers' => $tokenizers, 'ignore' => $ignorePatterns, 'include' => $includePatterns, ]; } } }//end foreach }//end populateTokenListeners() /** * Set a single property for a sniff. * * @param string $sniffClass The class name of the sniff. * @param string $name The name of the property to change. * @param string $value The new value of the property. * * @return void */ public function setSniffProperty($sniffClass, $name, $value) { // Setting a property for a sniff we are not using. if (isset($this->sniffs[$sniffClass]) === false) { return; } $name = trim($name); if (is_string($value) === true) { $value = trim($value); } if ($value === '') { $value = null; } // Special case for booleans. if ($value === 'true') { $value = true; } else if ($value === 'false') { $value = false; } else if (substr($name, -2) === '[]') { $name = substr($name, 0, -2); $values = []; if ($value !== null) { foreach (explode(',', $value) as $val) { list($k, $v) = explode('=>', $val.'=>'); if ($v !== '') { $values[trim($k)] = trim($v); } else { $values[] = trim($k); } } } $value = $values; } $this->sniffs[$sniffClass]->$name = $value; }//end setSniffProperty() /** * Gets the array of ignore patterns. * * Optionally takes a listener to get ignore patterns specified * for that sniff only. * * @param string $listener The listener to get patterns for. If NULL, all * patterns are returned. * * @return array */ public function getIgnorePatterns($listener=null) { if ($listener === null) { return $this->ignorePatterns; } if (isset($this->ignorePatterns[$listener]) === true) { return $this->ignorePatterns[$listener]; } return []; }//end getIgnorePatterns() /** * Gets the array of include patterns. * * Optionally takes a listener to get include patterns specified * for that sniff only. * * @param string $listener The listener to get patterns for. If NULL, all * patterns are returned. * * @return array */ public function getIncludePatterns($listener=null) { if ($listener === null) { return $this->includePatterns; } if (isset($this->includePatterns[$listener]) === true) { return $this->includePatterns[$listener]; } return []; }//end getIncludePatterns() }//end class PHP_CodeSniffer-3.5.4/src/Runner.php0000644000076500000240000007644613614652362017107 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer; use PHP_CodeSniffer\Exceptions\DeepExitException; use PHP_CodeSniffer\Exceptions\RuntimeException; use PHP_CodeSniffer\Files\DummyFile; use PHP_CodeSniffer\Files\File; use PHP_CodeSniffer\Files\FileList; use PHP_CodeSniffer\Util\Cache; use PHP_CodeSniffer\Util\Common; use PHP_CodeSniffer\Util\Standards; class Runner { /** * The config data for the run. * * @var \PHP_CodeSniffer\Config */ public $config = null; /** * The ruleset used for the run. * * @var \PHP_CodeSniffer\Ruleset */ public $ruleset = null; /** * The reporter used for generating reports after the run. * * @var \PHP_CodeSniffer\Reporter */ public $reporter = null; /** * Run the PHPCS script. * * @return array */ public function runPHPCS() { try { Util\Timing::startTiming(); Runner::checkRequirements(); if (defined('PHP_CODESNIFFER_CBF') === false) { define('PHP_CODESNIFFER_CBF', false); } // Creating the Config object populates it with all required settings // based on the CLI arguments provided to the script and any config // values the user has set. $this->config = new Config(); // Init the run and load the rulesets to set additional config vars. $this->init(); // Print a list of sniffs in each of the supplied standards. // We fudge the config here so that each standard is explained in isolation. if ($this->config->explain === true) { $standards = $this->config->standards; foreach ($standards as $standard) { $this->config->standards = [$standard]; $ruleset = new Ruleset($this->config); $ruleset->explain(); } return 0; } // Generate documentation for each of the supplied standards. if ($this->config->generator !== null) { $standards = $this->config->standards; foreach ($standards as $standard) { $this->config->standards = [$standard]; $ruleset = new Ruleset($this->config); $class = 'PHP_CodeSniffer\Generators\\'.$this->config->generator; $generator = new $class($ruleset); $generator->generate(); } return 0; } // Other report formats don't really make sense in interactive mode // so we hard-code the full report here and when outputting. // We also ensure parallel processing is off because we need to do one file at a time. if ($this->config->interactive === true) { $this->config->reports = ['full' => null]; $this->config->parallel = 1; $this->config->showProgress = false; } // Disable caching if we are processing STDIN as we can't be 100% // sure where the file came from or if it will change in the future. if ($this->config->stdin === true) { $this->config->cache = false; } $numErrors = $this->run(); // Print all the reports for this run. $toScreen = $this->reporter->printReports(); // Only print timer output if no reports were // printed to the screen so we don't put additional output // in something like an XML report. If we are printing to screen, // the report types would have already worked out who should // print the timer info. if ($this->config->interactive === false && ($toScreen === false || (($this->reporter->totalErrors + $this->reporter->totalWarnings) === 0 && $this->config->showProgress === true)) ) { Util\Timing::printRunTime(); } } catch (DeepExitException $e) { echo $e->getMessage(); return $e->getCode(); }//end try if ($numErrors === 0) { // No errors found. return 0; } else if ($this->reporter->totalFixable === 0) { // Errors found, but none of them can be fixed by PHPCBF. return 1; } else { // Errors found, and some can be fixed by PHPCBF. return 2; } }//end runPHPCS() /** * Run the PHPCBF script. * * @return array */ public function runPHPCBF() { if (defined('PHP_CODESNIFFER_CBF') === false) { define('PHP_CODESNIFFER_CBF', true); } try { Util\Timing::startTiming(); Runner::checkRequirements(); // Creating the Config object populates it with all required settings // based on the CLI arguments provided to the script and any config // values the user has set. $this->config = new Config(); // When processing STDIN, we can't output anything to the screen // or it will end up mixed in with the file output. if ($this->config->stdin === true) { $this->config->verbosity = 0; } // Init the run and load the rulesets to set additional config vars. $this->init(); // When processing STDIN, we only process one file at a time and // we don't process all the way through, so we can't use the parallel // running system. if ($this->config->stdin === true) { $this->config->parallel = 1; } // Override some of the command line settings that might break the fixes. $this->config->generator = null; $this->config->explain = false; $this->config->interactive = false; $this->config->cache = false; $this->config->showSources = false; $this->config->recordErrors = false; $this->config->reportFile = null; $this->config->reports = ['cbf' => null]; // If a standard tries to set command line arguments itself, some // may be blocked because PHPCBF is running, so stop the script // dying if any are found. $this->config->dieOnUnknownArg = false; $this->run(); $this->reporter->printReports(); echo PHP_EOL; Util\Timing::printRunTime(); } catch (DeepExitException $e) { echo $e->getMessage(); return $e->getCode(); }//end try if ($this->reporter->totalFixed === 0) { // Nothing was fixed by PHPCBF. if ($this->reporter->totalFixable === 0) { // Nothing found that could be fixed. return 0; } else { // Something failed to fix. return 2; } } if ($this->reporter->totalFixable === 0) { // PHPCBF fixed all fixable errors. return 1; } // PHPCBF fixed some fixable errors, but others failed to fix. return 2; }//end runPHPCBF() /** * Exits if the minimum requirements of PHP_CodeSniffer are not met. * * @return array * @throws \PHP_CodeSniffer\Exceptions\DeepExitException If the requirements are not met. */ public function checkRequirements() { // Check the PHP version. if (PHP_VERSION_ID < 50400) { $error = 'ERROR: PHP_CodeSniffer requires PHP version 5.4.0 or greater.'.PHP_EOL; throw new DeepExitException($error, 3); } $requiredExtensions = [ 'tokenizer', 'xmlwriter', 'SimpleXML', ]; $missingExtensions = []; foreach ($requiredExtensions as $extension) { if (extension_loaded($extension) === false) { $missingExtensions[] = $extension; } } if (empty($missingExtensions) === false) { $last = array_pop($requiredExtensions); $required = implode(', ', $requiredExtensions); $required .= ' and '.$last; if (count($missingExtensions) === 1) { $missing = $missingExtensions[0]; } else { $last = array_pop($missingExtensions); $missing = implode(', ', $missingExtensions); $missing .= ' and '.$last; } $error = 'ERROR: PHP_CodeSniffer requires the %s extensions to be enabled. Please enable %s.'.PHP_EOL; $error = sprintf($error, $required, $missing); throw new DeepExitException($error, 3); } }//end checkRequirements() /** * Init the rulesets and other high-level settings. * * @return void * @throws \PHP_CodeSniffer\Exceptions\DeepExitException If a referenced standard is not installed. */ public function init() { if (defined('PHP_CODESNIFFER_CBF') === false) { define('PHP_CODESNIFFER_CBF', false); } // Ensure this option is enabled or else line endings will not always // be detected properly for files created on a Mac with the /r line ending. ini_set('auto_detect_line_endings', true); // Disable the PCRE JIT as this caused issues with parallel running. ini_set('pcre.jit', false); // Check that the standards are valid. foreach ($this->config->standards as $standard) { if (Util\Standards::isInstalledStandard($standard) === false) { // They didn't select a valid coding standard, so help them // out by letting them know which standards are installed. $error = 'ERROR: the "'.$standard.'" coding standard is not installed. '; ob_start(); Util\Standards::printInstalledStandards(); $error .= ob_get_contents(); ob_end_clean(); throw new DeepExitException($error, 3); } } // Saves passing the Config object into other objects that only need // the verbosity flag for debug output. if (defined('PHP_CODESNIFFER_VERBOSITY') === false) { define('PHP_CODESNIFFER_VERBOSITY', $this->config->verbosity); } // Create this class so it is autoloaded and sets up a bunch // of PHP_CodeSniffer-specific token type constants. $tokens = new Util\Tokens(); // Allow autoloading of custom files inside installed standards. $installedStandards = Standards::getInstalledStandardDetails(); foreach ($installedStandards as $name => $details) { Autoload::addSearchPath($details['path'], $details['namespace']); } // The ruleset contains all the information about how the files // should be checked and/or fixed. try { $this->ruleset = new Ruleset($this->config); } catch (RuntimeException $e) { $error = 'ERROR: '.$e->getMessage().PHP_EOL.PHP_EOL; $error .= $this->config->printShortUsage(true); throw new DeepExitException($error, 3); } }//end init() /** * Performs the run. * * @return int The number of errors and warnings found. * @throws \PHP_CodeSniffer\Exceptions\DeepExitException * @throws \PHP_CodeSniffer\Exceptions\RuntimeException */ private function run() { // The class that manages all reporters for the run. $this->reporter = new Reporter($this->config); // Include bootstrap files. foreach ($this->config->bootstrap as $bootstrap) { include $bootstrap; } if ($this->config->stdin === true) { $fileContents = $this->config->stdinContent; if ($fileContents === null) { $handle = fopen('php://stdin', 'r'); stream_set_blocking($handle, true); $fileContents = stream_get_contents($handle); fclose($handle); } $todo = new FileList($this->config, $this->ruleset); $dummy = new DummyFile($fileContents, $this->ruleset, $this->config); $todo->addFile($dummy->path, $dummy); } else { if (empty($this->config->files) === true) { $error = 'ERROR: You must supply at least one file or directory to process.'.PHP_EOL.PHP_EOL; $error .= $this->config->printShortUsage(true); throw new DeepExitException($error, 3); } if (PHP_CODESNIFFER_VERBOSITY > 0) { echo 'Creating file list... '; } $todo = new FileList($this->config, $this->ruleset); if (PHP_CODESNIFFER_VERBOSITY > 0) { $numFiles = count($todo); echo "DONE ($numFiles files in queue)".PHP_EOL; } if ($this->config->cache === true) { if (PHP_CODESNIFFER_VERBOSITY > 0) { echo 'Loading cache... '; } Cache::load($this->ruleset, $this->config); if (PHP_CODESNIFFER_VERBOSITY > 0) { $size = Cache::getSize(); echo "DONE ($size files in cache)".PHP_EOL; } } }//end if // Turn all sniff errors into exceptions. set_error_handler([$this, 'handleErrors']); // If verbosity is too high, turn off parallelism so the // debug output is clean. if (PHP_CODESNIFFER_VERBOSITY > 1) { $this->config->parallel = 1; } // If the PCNTL extension isn't installed, we can't fork. if (function_exists('pcntl_fork') === false) { $this->config->parallel = 1; } $lastDir = ''; $numFiles = count($todo); if ($this->config->parallel === 1) { // Running normally. $numProcessed = 0; foreach ($todo as $path => $file) { if ($file->ignored === false) { $currDir = dirname($path); if ($lastDir !== $currDir) { if (PHP_CODESNIFFER_VERBOSITY > 0) { echo 'Changing into directory '.Common::stripBasepath($currDir, $this->config->basepath).PHP_EOL; } $lastDir = $currDir; } $this->processFile($file); } else if (PHP_CODESNIFFER_VERBOSITY > 0) { echo 'Skipping '.basename($file->path).PHP_EOL; } $numProcessed++; $this->printProgress($file, $numFiles, $numProcessed); } } else { // Batching and forking. $childProcs = []; $numPerBatch = ceil($numFiles / $this->config->parallel); for ($batch = 0; $batch < $this->config->parallel; $batch++) { $startAt = ($batch * $numPerBatch); if ($startAt >= $numFiles) { break; } $endAt = ($startAt + $numPerBatch); if ($endAt > $numFiles) { $endAt = $numFiles; } $childOutFilename = tempnam(sys_get_temp_dir(), 'phpcs-child'); $pid = pcntl_fork(); if ($pid === -1) { throw new RuntimeException('Failed to create child process'); } else if ($pid !== 0) { $childProcs[] = [ 'pid' => $pid, 'out' => $childOutFilename, ]; } else { // Move forward to the start of the batch. $todo->rewind(); for ($i = 0; $i < $startAt; $i++) { $todo->next(); } // Reset the reporter to make sure only figures from this // file batch are recorded. $this->reporter->totalFiles = 0; $this->reporter->totalErrors = 0; $this->reporter->totalWarnings = 0; $this->reporter->totalFixable = 0; $this->reporter->totalFixed = 0; // Process the files. $pathsProcessed = []; ob_start(); for ($i = $startAt; $i < $endAt; $i++) { $path = $todo->key(); $file = $todo->current(); if ($file->ignored === true) { continue; } $currDir = dirname($path); if ($lastDir !== $currDir) { if (PHP_CODESNIFFER_VERBOSITY > 0) { echo 'Changing into directory '.Common::stripBasepath($currDir, $this->config->basepath).PHP_EOL; } $lastDir = $currDir; } $this->processFile($file); $pathsProcessed[] = $path; $todo->next(); }//end for $debugOutput = ob_get_contents(); ob_end_clean(); // Write information about the run to the filesystem // so it can be picked up by the main process. $childOutput = [ 'totalFiles' => $this->reporter->totalFiles, 'totalErrors' => $this->reporter->totalErrors, 'totalWarnings' => $this->reporter->totalWarnings, 'totalFixable' => $this->reporter->totalFixable, 'totalFixed' => $this->reporter->totalFixed, ]; $output = '<'.'?php'."\n".' $childOutput = '; $output .= var_export($childOutput, true); $output .= ";\n\$debugOutput = "; $output .= var_export($debugOutput, true); if ($this->config->cache === true) { $childCache = []; foreach ($pathsProcessed as $path) { $childCache[$path] = Cache::get($path); } $output .= ";\n\$childCache = "; $output .= var_export($childCache, true); } $output .= ";\n?".'>'; file_put_contents($childOutFilename, $output); exit($pid); }//end if }//end for $success = $this->processChildProcs($childProcs); if ($success === false) { throw new RuntimeException('One or more child processes failed to run'); } }//end if restore_error_handler(); if (PHP_CODESNIFFER_VERBOSITY === 0 && $this->config->interactive === false && $this->config->showProgress === true ) { echo PHP_EOL.PHP_EOL; } if ($this->config->cache === true) { Cache::save(); } $ignoreWarnings = Config::getConfigData('ignore_warnings_on_exit'); $ignoreErrors = Config::getConfigData('ignore_errors_on_exit'); $return = ($this->reporter->totalErrors + $this->reporter->totalWarnings); if ($ignoreErrors !== null) { $ignoreErrors = (bool) $ignoreErrors; if ($ignoreErrors === true) { $return -= $this->reporter->totalErrors; } } if ($ignoreWarnings !== null) { $ignoreWarnings = (bool) $ignoreWarnings; if ($ignoreWarnings === true) { $return -= $this->reporter->totalWarnings; } } return $return; }//end run() /** * Converts all PHP errors into exceptions. * * This method forces a sniff to stop processing if it is not * able to handle a specific piece of code, instead of continuing * and potentially getting into a loop. * * @param int $code The level of error raised. * @param string $message The error message. * @param string $file The path of the file that raised the error. * @param int $line The line number the error was raised at. * * @return void * @throws \PHP_CodeSniffer\Exceptions\RuntimeException */ public function handleErrors($code, $message, $file, $line) { if ((error_reporting() & $code) === 0) { // This type of error is being muted. return true; } throw new RuntimeException("$message in $file on line $line"); }//end handleErrors() /** * Processes a single file, including checking and fixing. * * @param \PHP_CodeSniffer\Files\File $file The file to be processed. * * @return void * @throws \PHP_CodeSniffer\Exceptions\DeepExitException */ public function processFile($file) { if (PHP_CODESNIFFER_VERBOSITY > 0) { $startTime = microtime(true); echo 'Processing '.basename($file->path).' '; if (PHP_CODESNIFFER_VERBOSITY > 1) { echo PHP_EOL; } } try { $file->process(); if (PHP_CODESNIFFER_VERBOSITY > 0) { $timeTaken = ((microtime(true) - $startTime) * 1000); if ($timeTaken < 1000) { $timeTaken = round($timeTaken); echo "DONE in {$timeTaken}ms"; } else { $timeTaken = round(($timeTaken / 1000), 2); echo "DONE in $timeTaken secs"; } if (PHP_CODESNIFFER_CBF === true) { $errors = $file->getFixableCount(); echo " ($errors fixable violations)".PHP_EOL; } else { $errors = $file->getErrorCount(); $warnings = $file->getWarningCount(); echo " ($errors errors, $warnings warnings)".PHP_EOL; } } } catch (\Exception $e) { $error = 'An error occurred during processing; checking has been aborted. The error message was: '.$e->getMessage(); $file->addErrorOnLine($error, 1, 'Internal.Exception'); }//end try $this->reporter->cacheFileReport($file, $this->config); if ($this->config->interactive === true) { /* Running interactively. Print the error report for the current file and then wait for user input. */ // Get current violations and then clear the list to make sure // we only print violations for a single file each time. $numErrors = null; while ($numErrors !== 0) { $numErrors = ($file->getErrorCount() + $file->getWarningCount()); if ($numErrors === 0) { continue; } $this->reporter->printReport('full'); echo ' to recheck, [s] to skip or [q] to quit : '; $input = fgets(STDIN); $input = trim($input); switch ($input) { case 's': break(2); case 'q': throw new DeepExitException('', 0); default: // Repopulate the sniffs because some of them save their state // and only clear it when the file changes, but we are rechecking // the same file. $file->ruleset->populateTokenListeners(); $file->reloadContent(); $file->process(); $this->reporter->cacheFileReport($file, $this->config); break; } }//end while }//end if // Clean up the file to save (a lot of) memory. $file->cleanUp(); }//end processFile() /** * Waits for child processes to complete and cleans up after them. * * The reporting information returned by each child process is merged * into the main reporter class. * * @param array $childProcs An array of child processes to wait for. * * @return bool */ private function processChildProcs($childProcs) { $numProcessed = 0; $totalBatches = count($childProcs); $success = true; while (count($childProcs) > 0) { foreach ($childProcs as $key => $procData) { $res = pcntl_waitpid($procData['pid'], $status, WNOHANG); if ($res === $procData['pid']) { if (file_exists($procData['out']) === true) { include $procData['out']; unlink($procData['out']); unset($childProcs[$key]); $numProcessed++; if (isset($childOutput) === false) { // The child process died, so the run has failed. $file = new DummyFile(null, $this->ruleset, $this->config); $file->setErrorCounts(1, 0, 0, 0); $this->printProgress($file, $totalBatches, $numProcessed); $success = false; continue; } $this->reporter->totalFiles += $childOutput['totalFiles']; $this->reporter->totalErrors += $childOutput['totalErrors']; $this->reporter->totalWarnings += $childOutput['totalWarnings']; $this->reporter->totalFixable += $childOutput['totalFixable']; $this->reporter->totalFixed += $childOutput['totalFixed']; if (isset($debugOutput) === true) { echo $debugOutput; } if (isset($childCache) === true) { foreach ($childCache as $path => $cache) { Cache::set($path, $cache); } } // Fake a processed file so we can print progress output for the batch. $file = new DummyFile(null, $this->ruleset, $this->config); $file->setErrorCounts( $childOutput['totalErrors'], $childOutput['totalWarnings'], $childOutput['totalFixable'], $childOutput['totalFixed'] ); $this->printProgress($file, $totalBatches, $numProcessed); }//end if }//end if }//end foreach }//end while return $success; }//end processChildProcs() /** * Print progress information for a single processed file. * * @param \PHP_CodeSniffer\Files\File $file The file that was processed. * @param int $numFiles The total number of files to process. * @param int $numProcessed The number of files that have been processed, * including this one. * * @return void */ public function printProgress(File $file, $numFiles, $numProcessed) { if (PHP_CODESNIFFER_VERBOSITY > 0 || $this->config->showProgress === false ) { return; } // Show progress information. if ($file->ignored === true) { echo 'S'; } else { $errors = $file->getErrorCount(); $warnings = $file->getWarningCount(); $fixable = $file->getFixableCount(); $fixed = $file->getFixedCount(); if (PHP_CODESNIFFER_CBF === true) { // Files with fixed errors or warnings are F (green). // Files with unfixable errors or warnings are E (red). // Files with no errors or warnings are . (black). if ($fixable > 0) { if ($this->config->colors === true) { echo "\033[31m"; } echo 'E'; if ($this->config->colors === true) { echo "\033[0m"; } } else if ($fixed > 0) { if ($this->config->colors === true) { echo "\033[32m"; } echo 'F'; if ($this->config->colors === true) { echo "\033[0m"; } } else { echo '.'; }//end if } else { // Files with errors are E (red). // Files with fixable errors are E (green). // Files with warnings are W (yellow). // Files with fixable warnings are W (green). // Files with no errors or warnings are . (black). if ($errors > 0) { if ($this->config->colors === true) { if ($fixable > 0) { echo "\033[32m"; } else { echo "\033[31m"; } } echo 'E'; if ($this->config->colors === true) { echo "\033[0m"; } } else if ($warnings > 0) { if ($this->config->colors === true) { if ($fixable > 0) { echo "\033[32m"; } else { echo "\033[33m"; } } echo 'W'; if ($this->config->colors === true) { echo "\033[0m"; } } else { echo '.'; }//end if }//end if }//end if $numPerLine = 60; if ($numProcessed !== $numFiles && ($numProcessed % $numPerLine) !== 0) { return; } $percent = round(($numProcessed / $numFiles) * 100); $padding = (strlen($numFiles) - strlen($numProcessed)); if ($numProcessed === $numFiles && $numFiles > $numPerLine) { $padding += ($numPerLine - ($numFiles - (floor($numFiles / $numPerLine) * $numPerLine))); } echo str_repeat(' ', $padding)." $numProcessed / $numFiles ($percent%)".PHP_EOL; }//end printProgress() }//end class PHP_CodeSniffer-3.5.4/autoload.php0000644000076500000240000002354513614652362016647 0ustar gsherwoodstaff * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600) * @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence */ namespace PHP_CodeSniffer; if (class_exists('PHP_CodeSniffer\Autoload', false) === false) { class Autoload { /** * The composer autoloader. * * @var \Composer\Autoload\ClassLoader */ private static $composerAutoloader = null; /** * A mapping of file names to class names. * * @var array */ private static $loadedClasses = []; /** * A mapping of class names to file names. * * @var array */ private static $loadedFiles = []; /** * A list of additional directories to search during autoloading. * * This is typically a list of coding standard directories. * * @var string[] */ private static $searchPaths = []; /** * Loads a class. * * This method only loads classes that exist in the PHP_CodeSniffer namespace. * All other classes are ignored and loaded by subsequent autoloaders. * * @param string $class The name of the class to load. * * @return bool */ public static function load($class) { // Include the composer autoloader if there is one, but re-register it // so this autoloader runs before the composer one as we need to include // all files so we can figure out what the class/interface/trait name is. if (self::$composerAutoloader === null) { // Make sure we don't try to load any of Composer's classes // while the autoloader is being setup. if (strpos($class, 'Composer\\') === 0) { return; } if (strpos(__DIR__, 'phar://') !== 0 && @file_exists(__DIR__.'/../../autoload.php') === true ) { self::$composerAutoloader = include __DIR__.'/../../autoload.php'; if (self::$composerAutoloader instanceof \Composer\Autoload\ClassLoader) { self::$composerAutoloader->unregister(); self::$composerAutoloader->register(); } else { // Something went wrong, so keep going without the autoloader // although namespaced sniffs might error. self::$composerAutoloader = false; } } else { self::$composerAutoloader = false; } }//end if $ds = DIRECTORY_SEPARATOR; $path = false; if (substr($class, 0, 16) === 'PHP_CodeSniffer\\') { if (substr($class, 0, 22) === 'PHP_CodeSniffer\Tests\\') { $isInstalled = !is_dir(__DIR__.$ds.'tests'); if ($isInstalled === false) { $path = __DIR__.$ds.'tests'; } else { $path = '@test_dir@'.$ds.'PHP_CodeSniffer'.$ds.'CodeSniffer'; } $path .= $ds.substr(str_replace('\\', $ds, $class), 22).'.php'; } else { $path = __DIR__.$ds.'src'.$ds.substr(str_replace('\\', $ds, $class), 16).'.php'; } } // See if the composer autoloader knows where the class is. if ($path === false && self::$composerAutoloader !== false) { $path = self::$composerAutoloader->findFile($class); } // See if the class is inside one of our alternate search paths. if ($path === false) { foreach (self::$searchPaths as $searchPath => $nsPrefix) { $className = $class; if ($nsPrefix !== '' && substr($class, 0, strlen($nsPrefix)) === $nsPrefix) { $className = substr($class, (strlen($nsPrefix) + 1)); } $path = $searchPath.$ds.str_replace('\\', $ds, $className).'.php'; if (is_file($path) === true) { break; } $path = false; } } if ($path !== false && is_file($path) === true) { self::loadFile($path); return true; } return false; }//end load() /** * Includes a file and tracks what class or interface was loaded as a result. * * @param string $path The path of the file to load. * * @return string The fully qualified name of the class in the loaded file. */ public static function loadFile($path) { if (strpos(__DIR__, 'phar://') !== 0) { $path = realpath($path); if ($path === false) { return false; } } if (isset(self::$loadedClasses[$path]) === true) { return self::$loadedClasses[$path]; } $classes = get_declared_classes(); $interfaces = get_declared_interfaces(); $traits = get_declared_traits(); include $path; $className = null; $newClasses = array_reverse(array_diff(get_declared_classes(), $classes)); foreach ($newClasses as $name) { if (isset(self::$loadedFiles[$name]) === false) { $className = $name; break; } } if ($className === null) { $newClasses = array_reverse(array_diff(get_declared_interfaces(), $interfaces)); foreach ($newClasses as $name) { if (isset(self::$loadedFiles[$name]) === false) { $className = $name; break; } } } if ($className === null) { $newClasses = array_reverse(array_diff(get_declared_traits(), $traits)); foreach ($newClasses as $name) { if (isset(self::$loadedFiles[$name]) === false) { $className = $name; break; } } } self::$loadedClasses[$path] = $className; self::$loadedFiles[$className] = $path; return self::$loadedClasses[$path]; }//end loadFile() /** * Adds a directory to search during autoloading. * * @param string $path The path to the directory to search. * @param string $nsPrefix The namespace prefix used by files under this path. * * @return void */ public static function addSearchPath($path, $nsPrefix='') { self::$searchPaths[$path] = rtrim(trim((string) $nsPrefix), '\\'); }//end addSearchPath() /** * Retrieve the namespaces and paths registered by external standards. * * @return array */ public static function getSearchPaths() { return self::$searchPaths; }//end getSearchPaths() /** * Gets the class name for the given file path. * * @param string $path The name of the file. * * @throws \Exception If the file path has not been loaded. * @return string */ public static function getLoadedClassName($path) { if (isset(self::$loadedClasses[$path]) === false) { throw new \Exception("Cannot get class name for $path; file has not been included"); } return self::$loadedClasses[$path]; }//end getLoadedClassName() /** * Gets the file path for the given class name. * * @param string $class The name of the class. * * @throws \Exception If the class name has not been loaded * @return string */ public static function getLoadedFileName($class) { if (isset(self::$loadedFiles[$class]) === false) { throw new \Exception("Cannot get file name for $class; class has not been included"); } return self::$loadedFiles[$class]; }//end getLoadedFileName() /** * Gets the mapping of file names to class names. * * @return array */ public static function getLoadedClasses() { return self::$loadedClasses; }//end getLoadedClasses() /** * Gets the mapping of class names to file names. * * @return array */ public static function getLoadedFiles() { return self::$loadedFiles; }//end getLoadedFiles() }//end class // Register the autoloader before any existing autoloaders to ensure // it gets a chance to hear about every autoload request, and record // the file and class name for it. spl_autoload_register(__NAMESPACE__.'\Autoload::load', true, true); }//end if PHP_CodeSniffer-3.5.4/CodeSniffer.conf.dist0000644000076500000240000000027313614652362020317 0ustar gsherwoodstaff 'PSR2', 'report_format' => 'summary', 'show_warnings' => '0', 'show_progress' => '1', 'report_width' => '120', ) ?> PHP_CodeSniffer-3.5.4/README.md0000644000076500000240000001437713614652362015610 0ustar gsherwoodstaff## About PHP_CodeSniffer is a set of two PHP scripts; the main `phpcs` script that tokenizes PHP, JavaScript and CSS files to detect violations of a defined coding standard, and a second `phpcbf` script to automatically correct coding standard violations. PHP_CodeSniffer is an essential development tool that ensures your code remains clean and consistent. [![Build Status](https://travis-ci.org/squizlabs/PHP_CodeSniffer.svg?branch=phpcs-fixer)](https://travis-ci.org/squizlabs/PHP_CodeSniffer) [![Code consistency](http://squizlabs.github.io/PHP_CodeSniffer/analysis/squizlabs/PHP_CodeSniffer/grade.svg)](http://squizlabs.github.io/PHP_CodeSniffer/analysis/squizlabs/PHP_CodeSniffer) [![Join the chat at https://gitter.im/squizlabs/PHP_CodeSniffer](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/squizlabs/PHP_CodeSniffer?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) ## Requirements PHP_CodeSniffer requires PHP version 5.4.0 or greater, although individual sniffs may have additional requirements such as external applications and scripts. See the [Configuration Options manual page](https://github.com/squizlabs/PHP_CodeSniffer/wiki/Configuration-Options) for a list of these requirements. If you're using PHP_CodeSniffer as part of a team, or you're running it on a [CI](https://en.wikipedia.org/wiki/Continuous_integration) server, you may want to configure your project's settings [using a configuration file](https://github.com/squizlabs/PHP_CodeSniffer/wiki/Advanced-Usage#using-a-default-configuration-file). ## Installation The easiest way to get started with PHP_CodeSniffer is to download the Phar files for each of the commands: ``` # Download using curl curl -OL https://squizlabs.github.io/PHP_CodeSniffer/phpcs.phar curl -OL https://squizlabs.github.io/PHP_CodeSniffer/phpcbf.phar # Or download using wget wget https://squizlabs.github.io/PHP_CodeSniffer/phpcs.phar wget https://squizlabs.github.io/PHP_CodeSniffer/phpcbf.phar # Then test the downloaded PHARs php phpcs.phar -h php phpcbf.phar -h ``` ### Composer If you use Composer, you can install PHP_CodeSniffer system-wide with the following command: composer global require "squizlabs/php_codesniffer=*" Make sure you have the composer bin dir in your PATH. The default value is `~/.composer/vendor/bin/`, but you can check the value that you need to use by running `composer global config bin-dir --absolute`. Or alternatively, include a dependency for `squizlabs/php_codesniffer` in your `composer.json` file. For example: ```json { "require-dev": { "squizlabs/php_codesniffer": "3.*" } } ``` You will then be able to run PHP_CodeSniffer from the vendor bin directory: ./vendor/bin/phpcs -h ./vendor/bin/phpcbf -h ### Phive If you use Phive, you can install PHP_CodeSniffer as a project tool using the following commands: phive install phpcs phive install phpcbf You will then be able to run PHP_CodeSniffer from the tools directory: ./tools/phpcs -h ./tools/phpcbf -h ### PEAR If you use PEAR, you can install PHP_CodeSniffer using the PEAR installer. This will make the `phpcs` and `phpcbf` commands immediately available for use. To install PHP_CodeSniffer using the PEAR installer, first ensure you have [installed PEAR](http://pear.php.net/manual/en/installation.getting.php) and then run the following command: pear install PHP_CodeSniffer ### Git Clone You can also download the PHP_CodeSniffer source and run the `phpcs` and `phpcbf` commands directly from the Git clone: git clone https://github.com/squizlabs/PHP_CodeSniffer.git cd PHP_CodeSniffer php bin/phpcs -h php bin/phpcbf -h ## Getting Started The default coding standard used by PHP_CodeSniffer is the PEAR coding standard. To check a file against the PEAR coding standard, simply specify the file's location: $ phpcs /path/to/code/myfile.php Or if you wish to check an entire directory you can specify the directory location instead of a file. $ phpcs /path/to/code-directory If you wish to check your code against the PSR-2 coding standard, use the `--standard` command line argument: $ phpcs --standard=PSR2 /path/to/code-directory If PHP_CodeSniffer finds any coding standard errors, a report will be shown after running the command. Full usage information and example reports are available on the [usage page](https://github.com/squizlabs/PHP_CodeSniffer/wiki/Usage). ## Documentation The documentation for PHP_CodeSniffer is available on the [Github wiki](https://github.com/squizlabs/PHP_CodeSniffer/wiki). ## Issues Bug reports and feature requests can be submitted on the [Github Issue Tracker](https://github.com/squizlabs/PHP_CodeSniffer/issues). ## Contributing See [CONTRIBUTING.md](CONTRIBUTING.md) for information. ## Versioning PHP_CodeSniffer uses a `MAJOR.MINOR.PATCH` version number format. The `MAJOR` version is incremented when: - backwards-incompatible changes are made to how the `phpcs` or `phpcbf` commands are used, or - backwards-incompatible changes are made to the `ruleset.xml` format, or - backwards-incompatible changes are made to the API used by sniff developers, or - custom PHP_CodeSniffer token types are removed, or - existing sniffs are removed from PHP_CodeSniffer entirely The `MINOR` version is incremented when: - new backwards-compatible features are added to the `phpcs` and `phpcbf` commands, or - backwards-compatible changes are made to the `ruleset.xml` format, or - backwards-compatible changes are made to the API used by sniff developers, or - new sniffs are added to an included standard, or - existing sniffs are removed from an included standard > NOTE: Backwards-compatible changes to the API used by sniff developers will allow an existing sniff to continue running without producing fatal errors but may not result in the sniff reporting the same errors as it did previously without changes being required. The `PATCH` version is incremented when: - backwards-compatible bug fixes are made > NOTE: As PHP_CodeSniffer exists to report and fix issues, most bugs are the result of coding standard errors being incorrectly reported or coding standard errors not being reported when they should be. This means that the messages produced by PHP_CodeSniffer, and the fixes it makes, are likely to be different between PATCH versions. PHP_CodeSniffer-3.5.4/CONTRIBUTING.md0000644000076500000240000000117613614652362016553 0ustar gsherwoodstaffContributing ------------- Before you contribute code to PHP\_CodeSniffer, please make sure it conforms to the PHPCS coding standard and that the PHP\_CodeSniffer unit tests still pass. The easiest way to contribute is to work on a checkout of the repository, or your own fork, rather than an installed PEAR version. If you do this, you can run the following commands to check if everything is ready to submit: cd PHP_CodeSniffer php bin/phpcs Which should display no coding standard errors. And then: phpunit Which should give you no failures or errors. You can ignore any skipped tests as these are for external tools. PHP_CodeSniffer-3.5.4/licence.txt0000644000076500000240000000277513614652362016473 0ustar gsherwoodstaffCopyright (c) 2012, Squiz Pty Ltd (ABN 77 084 670 600) All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Squiz Pty Ltd nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. PHP_CodeSniffer-3.5.4/phpcs.xml.dist0000644000076500000240000001421013614652362017114 0ustar gsherwoodstaff The coding standard for PHP_CodeSniffer itself. autoload.php bin scripts src tests */src/Standards/*/Tests/*\.(inc|css|js)$ */tests/Core/*/*Test\.(inc|css|js)$ error 0 0 0 0 0 error error tests/bootstrap.php PHP_CodeSniffer-3.5.4/phpcs.xsd0000644000076500000240000001561613614652362016163 0ustar gsherwoodstaff PHP_CodeSniffer-3.5.4/phpunit.xml.dist0000644000076500000240000000047313614652362017474 0ustar gsherwoodstaff tests/AllTests.php