8738881283

Committed 18 Apr 2024 11:59AM UTC coverage: 72.418% (+0.04%) from 72.376%

Build # 8738881283

Build Type

push

github

Committed by

jrfnl

Commit Message

OtherContextSensitiveKeywordsTest: add silly number of extra tests

... to safeguard that the `true`/`false`/`null`/`self`/`parent` keywords, when used in type declarations, are correctly tokenized.

Run Details

17368 of 23983 relevant lines covered (72.42%)

58.81 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.77

/src/Standards/PSR2/Sniffs/Classes/ClassDeclarationSniff.php

<?php
/**
 * Checks the declaration of the class and its inheritance is correct.
 *
 * @author    Greg Sherwood <gsherwood@squiz.net>
 * @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600)
 * @license   https://github.com/PHPCSStandards/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.
        $classModifiers = [
            T_ABSTRACT => T_ABSTRACT,
            T_FINAL    => T_FINAL,
            T_READONLY => T_READONLY,
        ];

        $prevNonSpace = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true);
        $prevNonEmpty = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true);

        if (isset($classModifiers[$tokens[$prevNonEmpty]['code']]) === true) {
            $spaces    = 0;
            $errorCode = 'SpaceBeforeKeyword';
            if ($tokens[$prevNonEmpty]['line'] !== $tokens[$stackPtr]['line']) {
                $spaces    = 'newline';
                $errorCode = 'NewlineBeforeKeyword';
            } else if ($tokens[($stackPtr - 1)]['code'] === T_WHITESPACE) {
                $spaces = $tokens[($stackPtr - 1)]['length'];
            }

            if ($spaces !== 1) {
                $error = 'Expected 1 space between %s and %s keywords; %s found';
                $data  = [
                    strtolower($tokens[$prevNonEmpty]['content']),
                    $stackPtrType,
                    $spaces,
                ];

                if ($prevNonSpace !== $prevNonEmpty) {
                    // Comment found between modifier and class keyword. Do not auto-fix.
                    $phpcsFile->addError($error, $stackPtr, $errorCode, $data);
                } else {
                    $fix = $phpcsFile->addFixableError($error, $stackPtr, $errorCode, $data);
                    if ($fix === true) {
                        if ($spaces === 0) {
                            $phpcsFile->fixer->addContentBefore($stackPtr, ' ');
                        } else {
                            $phpcsFile->fixer->beginChangeset();
                            $phpcsFile->fixer->replaceToken(($stackPtr - 1), ' ');
                            for ($i = ($stackPtr - 2); $i > $prevNonSpace; $i--) {
                                $phpcsFile->fixer->replaceToken($i, ' ');
                            }

                            $phpcsFile->fixer->endChangeset();
                        }
                    }
                }
            }//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,
            T_NAME_QUALIFIED,
            T_NAME_FULLY_QUALIFIED,
            T_NAME_RELATIVE,
            $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) {
                $prev = $phpcsFile->findPrevious(
                    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 ((isset(Tokens::$commentTokens[$tokens[$prev]['code']]) === false
                    && $tokens[$prev]['line'] !== ($tokens[$className]['line'] - 1))
                    || $tokens[$prev]['line'] === $tokens[$className]['line']
                ) {
                    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 {
                // Not part of a longer fully qualified or namespace relative class name.
                if ($tokens[($className - 1)]['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_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); $tokens[$i]['line'] !== $tokens[$closeBrace]['line']; $i++) {
                    $phpcsFile->fixer->replaceToken($i, '');
                }

                if (strpos($tokens[$prevContent]['content'], $phpcsFile->eolChar) === false) {
                    $phpcsFile->fixer->addNewline($prevContent);
                }

                $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

1	<?php
2	/**
3	* Checks the declaration of the class and its inheritance is correct.
4	*
5	* @author Greg Sherwood <gsherwood@squiz.net>
6	* @copyright 2006-2015 Squiz Pty Ltd (ABN 77 084 670 600)
7	* @license https://github.com/PHPCSStandards/PHP_CodeSniffer/blob/master/licence.txt BSD Licence
8	*/
9
10	namespace PHP_CodeSniffer\Standards\PSR2\Sniffs\Classes;
11
12	use PHP_CodeSniffer\Files\File;
13	use PHP_CodeSniffer\Standards\PEAR\Sniffs\Classes\ClassDeclarationSniff as PEARClassDeclarationSniff;
14	use PHP_CodeSniffer\Util\Tokens;
15
16	class ClassDeclarationSniff extends PEARClassDeclarationSniff
17	{
18
19	/**
20	* The number of spaces code should be indented.
21	*
22	* @var integer
23	*/
24	public $indent = 4;
25
26
27	/**
28	* Processes this test, when one of its tokens is encountered.
29	*
30	* @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
31	* @param int $stackPtr The position of the current token
32	* in the stack passed in $tokens.
33	*
34	* @return void
35	*/
36	public function process(File $phpcsFile, $stackPtr)	3✔
37	{
38	// We want all the errors from the PEAR standard, plus some of our own.
39	parent::process($phpcsFile, $stackPtr);	3✔
40
41	// Just in case.
42	$tokens = $phpcsFile->getTokens();	3✔
43	if (isset($tokens[$stackPtr]['scope_opener']) === false) {	3✔
44	return;	×
45	}
46
47	$this->processOpen($phpcsFile, $stackPtr);	3✔
48	$this->processClose($phpcsFile, $stackPtr);	3✔
49
50	}//end process()	1✔
51
52
53	/**
54	* Processes the opening section of a class declaration.
55	*
56	* @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
57	* @param int $stackPtr The position of the current token
58	* in the stack passed in $tokens.
59	*
60	* @return void
61	*/
62	public function processOpen(File $phpcsFile, $stackPtr)	3✔
63	{
64	$tokens = $phpcsFile->getTokens();	3✔
65	$stackPtrType = strtolower($tokens[$stackPtr]['content']);	3✔
66
67	// Check alignment of the keyword and braces.
68	$classModifiers = [	2✔
69	T_ABSTRACT => T_ABSTRACT,	3✔
70	T_FINAL => T_FINAL,	3✔
71	T_READONLY => T_READONLY,	3✔
72	];	2✔
73
74	$prevNonSpace = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true);	3✔
75	$prevNonEmpty = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($stackPtr - 1), null, true);	3✔
76
77	if (isset($classModifiers[$tokens[$prevNonEmpty]['code']]) === true) {	3✔
78	$spaces = 0;	3✔
79	$errorCode = 'SpaceBeforeKeyword';	3✔
80	if ($tokens[$prevNonEmpty]['line'] !== $tokens[$stackPtr]['line']) {	3✔
81	$spaces = 'newline';	3✔
82	$errorCode = 'NewlineBeforeKeyword';	3✔
83	} else if ($tokens[($stackPtr - 1)]['code'] === T_WHITESPACE) {	3✔
84	$spaces = $tokens[($stackPtr - 1)]['length'];	3✔
85	}
86
87	if ($spaces !== 1) {	3✔
88	$error = 'Expected 1 space between %s and %s keywords; %s found';	3✔
89	$data = [	2✔
90	strtolower($tokens[$prevNonEmpty]['content']),	3✔
91	$stackPtrType,	3✔
92	$spaces,	3✔
93	];	2✔
94
95	if ($prevNonSpace !== $prevNonEmpty) {	3✔
96	// Comment found between modifier and class keyword. Do not auto-fix.
97	$phpcsFile->addError($error, $stackPtr, $errorCode, $data);	3✔
98	} else {
99	$fix = $phpcsFile->addFixableError($error, $stackPtr, $errorCode, $data);	3✔
100	if ($fix === true) {	3✔
101	if ($spaces === 0) {	3✔
102	$phpcsFile->fixer->addContentBefore($stackPtr, ' ');	×
103	} else {
104	$phpcsFile->fixer->beginChangeset();	3✔
105	$phpcsFile->fixer->replaceToken(($stackPtr - 1), ' ');	3✔
106	for ($i = ($stackPtr - 2); $i > $prevNonSpace; $i--) {	3✔
107	$phpcsFile->fixer->replaceToken($i, ' ');	3✔
108	}
109
110	$phpcsFile->fixer->endChangeset();	3✔
111	}
112	}
113	}
114	}//end if
115	}//end if
116
117	// We'll need the indent of the class/interface declaration for later.
118	$classIndent = 0;	3✔
119	for ($i = ($stackPtr - 1); $i > 0; $i--) {	3✔
120	if ($tokens[$i]['line'] === $tokens[$stackPtr]['line']) {	3✔
121	continue;	3✔
122	}
123
124	// We changed lines.
125	if ($tokens[($i + 1)]['code'] === T_WHITESPACE) {	3✔
126	$classIndent = $tokens[($i + 1)]['length'];	3✔
127	}
128
129	break;	3✔
130	}
131
132	$className = null;	3✔
133	$checkSpacing = true;	3✔
134
135	if ($tokens[$stackPtr]['code'] !== T_ANON_CLASS) {	3✔
136	$className = $phpcsFile->findNext(T_STRING, $stackPtr);	3✔
137	} else {
138	// Ignore the spacing check if this is a simple anon class.
139	$next = $phpcsFile->findNext(T_WHITESPACE, ($stackPtr + 1), null, true);	×
140	if ($next === $tokens[$stackPtr]['scope_opener']	×
141	&& $tokens[$next]['line'] > $tokens[$stackPtr]['line']	×
142	) {
143	$checkSpacing = false;	×
144	}
145	}
146
147	if ($checkSpacing === true) {	3✔
148	// Spacing of the keyword.
149	if ($tokens[($stackPtr + 1)]['code'] !== T_WHITESPACE) {	3✔
150	$gap = 0;	×
151	} else if ($tokens[($stackPtr + 2)]['line'] !== $tokens[$stackPtr]['line']) {	3✔
152	$gap = 'newline';	3✔
153	} else {
154	$gap = $tokens[($stackPtr + 1)]['length'];	3✔
155	}
156
157	if ($gap !== 1) {	3✔
158	$error = 'Expected 1 space after %s keyword; %s found';	3✔
159	$data = [	2✔
160	$stackPtrType,	3✔
161	$gap,	3✔
162	];	2✔
163
164	$fix = $phpcsFile->addFixableError($error, $stackPtr, 'SpaceAfterKeyword', $data);	3✔
165	if ($fix === true) {	3✔
166	if ($gap === 0) {	3✔
167	$phpcsFile->fixer->addContent($stackPtr, ' ');	×
168	} else {
169	$phpcsFile->fixer->replaceToken(($stackPtr + 1), ' ');	3✔
170	}
171	}
172	}
173	}//end if
174
175	// Check after the class/interface name.
176	if ($className !== null	3✔
177	&& $tokens[($className + 2)]['line'] === $tokens[$className]['line']	3✔
178	) {
179	$gap = $tokens[($className + 1)]['content'];	3✔
180	if (strlen($gap) !== 1) {	3✔
181	$found = strlen($gap);	×
182	$error = 'Expected 1 space after %s name; %s found';	×
183	$data = [
184	$stackPtrType,	×
185	$found,	×
186	];
187
188	$fix = $phpcsFile->addFixableError($error, $className, 'SpaceAfterName', $data);	×
189	if ($fix === true) {	×
190	$phpcsFile->fixer->replaceToken(($className + 1), ' ');	×
191	}
192	}
193	}
194
195	$openingBrace = $tokens[$stackPtr]['scope_opener'];	3✔
196
197	// Check positions of the extends and implements keywords.
198	$compareToken = $stackPtr;	3✔
199	$compareType = 'name';	3✔
200	if ($tokens[$stackPtr]['code'] === T_ANON_CLASS) {	3✔
201	if (isset($tokens[$stackPtr]['parenthesis_opener']) === true) {	×
202	$compareToken = $tokens[$stackPtr]['parenthesis_closer'];	×
203	$compareType = 'closing parenthesis';	×
204	} else {
205	$compareType = 'keyword';	×
206	}
207	}
208
209	foreach (['extends', 'implements'] as $keywordType) {	3✔
210	$keyword = $phpcsFile->findNext(constant('T_'.strtoupper($keywordType)), ($compareToken + 1), $openingBrace);	3✔
211	if ($keyword !== false) {	3✔
212	if ($tokens[$keyword]['line'] !== $tokens[$compareToken]['line']) {	3✔
213	$error = 'The '.$keywordType.' keyword must be on the same line as the %s '.$compareType;	3✔
214	$data = [$stackPtrType];	3✔
215	$fix = $phpcsFile->addFixableError($error, $keyword, ucfirst($keywordType).'Line', $data);	3✔
216	if ($fix === true) {	3✔
217	$phpcsFile->fixer->beginChangeset();	3✔
218	$comments = [];	3✔
219
220	for ($i = ($compareToken + 1); $i < $keyword; ++$i) {	3✔
221	if ($tokens[$i]['code'] === T_COMMENT) {	3✔
222	$comments[] = trim($tokens[$i]['content']);	3✔
223	}
224
225	if ($tokens[$i]['code'] === T_WHITESPACE	3✔
226	\|\| $tokens[$i]['code'] === T_COMMENT	3✔
227	) {
228	$phpcsFile->fixer->replaceToken($i, ' ');	3✔
229	}
230	}
231
232	$phpcsFile->fixer->addContent($compareToken, ' ');	3✔
233	if (empty($comments) === false) {	3✔
234	$i = $keyword;	3✔
235	while ($tokens[($i + 1)]['line'] === $tokens[$keyword]['line']) {	3✔
236	++$i;	3✔
237	}
238
239	$phpcsFile->fixer->addContentBefore($i, ' '.implode(' ', $comments));	3✔
240	}
241
242	$phpcsFile->fixer->endChangeset();	3✔
243	}//end if
244	} else {
245	// Check the whitespace before. Whitespace after is checked
246	// later by looking at the whitespace before the first class name
247	// in the list.
248	$gap = $tokens[($keyword - 1)]['length'];	3✔
249	if ($gap !== 1) {	3✔
250	$error = 'Expected 1 space before '.$keywordType.' keyword; %s found';	3✔
251	$data = [$gap];	3✔
252	$fix = $phpcsFile->addFixableError($error, $keyword, 'SpaceBefore'.ucfirst($keywordType), $data);	3✔
253	if ($fix === true) {	3✔
254	$phpcsFile->fixer->replaceToken(($keyword - 1), ' ');	3✔
255	}
256	}
257	}//end if
258	}//end if
259	}//end foreach
260
261	// Check each of the extends/implements class names. If the extends/implements
262	// keyword is the last content on the line, it means we need to check for
263	// the multi-line format, so we do not include the class names
264	// from the extends/implements list in the following check.
265	// Note that classes can only extend one other class, so they can't use a
266	// multi-line extends format, whereas an interface can extend multiple
267	// other interfaces, and so uses a multi-line extends format.
268	if ($tokens[$stackPtr]['code'] === T_INTERFACE) {	3✔
269	$keywordTokenType = T_EXTENDS;	3✔
270	} else {
271	$keywordTokenType = T_IMPLEMENTS;	3✔
272	}
273
274	$implements = $phpcsFile->findNext($keywordTokenType, ($stackPtr + 1), $openingBrace);	3✔
275	$multiLineImplements = false;	3✔
276	if ($implements !== false) {	3✔
277	$prev = $phpcsFile->findPrevious(Tokens::$emptyTokens, ($openingBrace - 1), $implements, true);	3✔
278	if ($tokens[$prev]['line'] !== $tokens[$implements]['line']) {	3✔
279	$multiLineImplements = true;	3✔
280	}
281	}
282
283	$find = [	2✔
284	T_STRING,	3✔
285	T_NAME_QUALIFIED,	3✔
286	T_NAME_FULLY_QUALIFIED,	3✔
287	T_NAME_RELATIVE,	3✔
288	$keywordTokenType,	3✔
289	];	2✔
290
291	if ($className !== null) {	3✔
292	$start = $className;	3✔
293	} else if (isset($tokens[$stackPtr]['parenthesis_closer']) === true) {	×
294	$start = $tokens[$stackPtr]['parenthesis_closer'];	×
295	} else {
296	$start = $stackPtr;	×
297	}
298
299	$classNames = [];	3✔
300	$nextClass = $phpcsFile->findNext($find, ($start + 2), ($openingBrace - 1));	3✔
301	while ($nextClass !== false) {	3✔
302	$classNames[] = $nextClass;	3✔
303	$nextClass = $phpcsFile->findNext($find, ($nextClass + 1), ($openingBrace - 1));	3✔
304	}
305
306	$classCount = count($classNames);	3✔
307	$checkingImplements = false;	3✔
308	$implementsToken = null;	3✔
309	foreach ($classNames as $n => $className) {	3✔
310	if ($tokens[$className]['code'] === $keywordTokenType) {	3✔
311	$checkingImplements = true;	3✔
312	$implementsToken = $className;	3✔
313
314	continue;	3✔
315	}
316
317	if ($checkingImplements === true && $multiLineImplements === true) {	3✔
318	$prev = $phpcsFile->findPrevious(	3✔
319	T_WHITESPACE,	3✔
320	($className - 1),	3✔
321	$implements,	3✔
322	true	3✔
323	);	2✔
324
325	if ($prev === $implementsToken && $tokens[$className]['line'] !== ($tokens[$prev]['line'] + 1)) {	3✔
326	if ($keywordTokenType === T_EXTENDS) {	3✔
327	$error = 'The first item in a multi-line extends list must be on the line following the extends keyword';	×
328	$fix = $phpcsFile->addFixableError($error, $className, 'FirstExtendsInterfaceSameLine');	×
329	} else {
330	$error = 'The first item in a multi-line implements list must be on the line following the implements keyword';	3✔
331	$fix = $phpcsFile->addFixableError($error, $className, 'FirstInterfaceSameLine');	3✔
332	}
333
334	if ($fix === true) {	3✔
335	$phpcsFile->fixer->beginChangeset();	3✔
336	for ($i = ($prev + 1); $i < $className; $i++) {	3✔
337	if ($tokens[$i]['code'] !== T_WHITESPACE) {	3✔
338	break;	×
339	}
340
341	$phpcsFile->fixer->replaceToken($i, '');	3✔
342	}
343
344	$phpcsFile->fixer->addNewline($prev);	3✔
345	$phpcsFile->fixer->endChangeset();	3✔
346	}
347	} else if ((isset(Tokens::$commentTokens[$tokens[$prev]['code']]) === false	3✔
348	&& $tokens[$prev]['line'] !== ($tokens[$className]['line'] - 1))	3✔
349	\|\| $tokens[$prev]['line'] === $tokens[$className]['line']	3✔
350	) {
351	if ($keywordTokenType === T_EXTENDS) {	3✔
352	$error = 'Only one interface may be specified per line in a multi-line extends declaration';	3✔
353	$fix = $phpcsFile->addFixableError($error, $className, 'ExtendsInterfaceSameLine');	3✔
354	} else {
355	$error = 'Only one interface may be specified per line in a multi-line implements declaration';	3✔
356	$fix = $phpcsFile->addFixableError($error, $className, 'InterfaceSameLine');	3✔
357	}
358
359	if ($fix === true) {	3✔
360	$phpcsFile->fixer->beginChangeset();	3✔
361	for ($i = ($prev + 1); $i < $className; $i++) {	3✔
362	if ($tokens[$i]['code'] !== T_WHITESPACE) {	3✔
363	break;	×
364	}
365
366	$phpcsFile->fixer->replaceToken($i, '');	3✔
367	}
368
369	$phpcsFile->fixer->addNewline($prev);	3✔
370	$phpcsFile->fixer->endChangeset();	3✔
371	}
372	} else {
373	$prev = $phpcsFile->findPrevious(T_WHITESPACE, ($className - 1), $implements);	3✔
374	if ($tokens[$prev]['line'] !== $tokens[$className]['line']) {	3✔
375	$found = 0;	3✔
376	} else {
377	$found = $tokens[$prev]['length'];	3✔
378	}
379
380	$expected = ($classIndent + $this->indent);	3✔
381	if ($found !== $expected) {	3✔
382	$error = 'Expected %s spaces before interface name; %s found';	3✔
383	$data = [	2✔
384	$expected,	3✔
385	$found,	3✔
386	];	2✔
387	$fix = $phpcsFile->addFixableError($error, $className, 'InterfaceWrongIndent', $data);	3✔
388	if ($fix === true) {	3✔
389	$padding = str_repeat(' ', $expected);	3✔
390	if ($found === 0) {	3✔
391	$phpcsFile->fixer->addContent($prev, $padding);	3✔
392	} else {
393	$phpcsFile->fixer->replaceToken($prev, $padding);	3✔
394	}
395	}
396	}
397	}//end if
398	} else {
399	// Not part of a longer fully qualified or namespace relative class name.
400	if ($tokens[($className - 1)]['code'] === T_COMMA) {	3✔
401	$error = 'Expected 1 space before "%s"; 0 found';	3✔
402	$data = [$tokens[$className]['content']];	3✔
403	$fix = $phpcsFile->addFixableError($error, ($nextComma + 1), 'NoSpaceBeforeName', $data);	3✔
404	if ($fix === true) {	3✔
405	$phpcsFile->fixer->addContentBefore(($nextComma + 1), ' ');	3✔
406	}
407	} else {
408	if ($tokens[($className - 1)]['code'] === T_NS_SEPARATOR) {	3✔
409	$prev = ($className - 2);	×
410	} else {
411	$prev = ($className - 1);	3✔
412	}
413
414	$last = $phpcsFile->findPrevious(T_WHITESPACE, $prev, null, true);	3✔
415	$content = $phpcsFile->getTokensAsString(($last + 1), ($prev - $last));	3✔
416	if ($content !== ' ') {	3✔
417	$found = strlen($content);	3✔
418
419	$error = 'Expected 1 space before "%s"; %s found';	3✔
420	$data = [	2✔
421	$tokens[$className]['content'],	3✔
422	$found,	3✔
423	];	2✔
424
425	$fix = $phpcsFile->addFixableError($error, $className, 'SpaceBeforeName', $data);	3✔
426	if ($fix === true) {	3✔
427	if ($tokens[$prev]['code'] === T_WHITESPACE) {	3✔
428	$phpcsFile->fixer->beginChangeset();	3✔
429	$phpcsFile->fixer->replaceToken($prev, ' ');	3✔
430	while ($tokens[--$prev]['code'] === T_WHITESPACE) {	3✔
431	$phpcsFile->fixer->replaceToken($prev, ' ');	3✔
432	}
433
434	$phpcsFile->fixer->endChangeset();	3✔
435	} else {
436	$phpcsFile->fixer->addContent($prev, ' ');	×
437	}
438	}
439	}//end if
440	}//end if
441	}//end if
442
443	if ($checkingImplements === true	3✔
444	&& $tokens[($className + 1)]['code'] !== T_COMMA	3✔
445	) {
446	if ($n !== ($classCount - 1)) {	3✔
447	// This is not the last class name, and the comma
448	// is not where we expect it to be.
449	if ($tokens[($className + 2)]['code'] !== $keywordTokenType) {	3✔
450	$error = 'Expected 0 spaces between "%s" and comma; %s found';	3✔
451	$data = [	2✔
452	$tokens[$className]['content'],	3✔
453	$tokens[($className + 1)]['length'],	3✔
454	];	2✔
455
456	$fix = $phpcsFile->addFixableError($error, $className, 'SpaceBeforeComma', $data);	3✔
457	if ($fix === true) {	3✔
458	$phpcsFile->fixer->replaceToken(($className + 1), '');	3✔
459	}
460	}
461	}
462
463	$nextComma = $phpcsFile->findNext(T_COMMA, $className);	3✔
464	} else {
465	$nextComma = ($className + 1);	3✔
466	}//end if
467	}//end foreach
468
469	}//end processOpen()	1✔
470
471
472	/**
473	* Processes the closing section of a class declaration.
474	*
475	* @param \PHP_CodeSniffer\Files\File $phpcsFile The file being scanned.
476	* @param int $stackPtr The position of the current token
477	* in the stack passed in $tokens.
478	*
479	* @return void
480	*/
481	public function processClose(File $phpcsFile, $stackPtr)	3✔
482	{
483	$tokens = $phpcsFile->getTokens();	3✔
484
485	// Check that the closing brace comes right after the code body.
486	$closeBrace = $tokens[$stackPtr]['scope_closer'];	3✔
487	$prevContent = $phpcsFile->findPrevious(T_WHITESPACE, ($closeBrace - 1), null, true);	3✔
488	if ($prevContent !== $tokens[$stackPtr]['scope_opener']	3✔
489	&& $tokens[$prevContent]['line'] !== ($tokens[$closeBrace]['line'] - 1)	3✔
490	) {
491	$error = 'The closing brace for the %s must go on the next line after the body';	3✔
492	$data = [$tokens[$stackPtr]['content']];	3✔
493	$fix = $phpcsFile->addFixableError($error, $closeBrace, 'CloseBraceAfterBody', $data);	3✔
494
495	if ($fix === true) {	3✔
496	$phpcsFile->fixer->beginChangeset();	3✔
497	for ($i = ($prevContent + 1); $tokens[$i]['line'] !== $tokens[$closeBrace]['line']; $i++) {	3✔
498	$phpcsFile->fixer->replaceToken($i, '');	3✔
499	}
500
501	if (strpos($tokens[$prevContent]['content'], $phpcsFile->eolChar) === false) {	3✔
502	$phpcsFile->fixer->addNewline($prevContent);	3✔
503	}
504
505	$phpcsFile->fixer->endChangeset();	3✔
506	}
507	}//end if
508
509	if ($tokens[$stackPtr]['code'] !== T_ANON_CLASS) {	3✔
510	// Check the closing brace is on it's own line, but allow
511	// for comments like "//end class".
512	$ignoreTokens = Tokens::$phpcsCommentTokens;	3✔
513	$ignoreTokens[] = T_WHITESPACE;	3✔
514	$ignoreTokens[] = T_COMMENT;	3✔
515	$ignoreTokens[] = T_SEMICOLON;	3✔
516	$ignoreTokens[] = T_COMMA;	3✔
517	$nextContent = $phpcsFile->findNext($ignoreTokens, ($closeBrace + 1), null, true);	3✔
518	if ($tokens[$nextContent]['content'] !== $phpcsFile->eolChar	3✔
519	&& $tokens[$nextContent]['line'] === $tokens[$closeBrace]['line']	3✔
520	) {
521	$type = strtolower($tokens[$stackPtr]['content']);	×
522	$error = 'Closing %s brace must be on a line by itself';	×
523	$data = [$type];	×
524	$phpcsFile->addError($error, $closeBrace, 'CloseBraceSameLine', $data);	×
525	}
526	}
527
528	}//end processClose()	1✔
529
530
531	}//end class

PHPCSStandards / PHP_CodeSniffer / 8738881283

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous