CodeIgniter\Sniffs\NamingConventions\ValidVariableNameSniff

Complexity

Total Complexity

64

Size/Duplication

Total Lines	518
Duplicated Lines	2.12 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	processMemberVar()	0	19	4
A	processVariable()	0	19	4
B	processVariableInString()	0	23	4
A	checkLowerCase()	0	21	3
C	checkVisibilityPrefix()	11	22	7
B	checkLength()	0	31	5
B	_isInForLoop()	0	21	5
B	_isInForLoopHead()	0	27	5
C	_isInForLoopBody()	0	78	12
A	_isDeclaredInForLoop()	0	18	3
B	_getVarDeclaredInFor()	0	26	3
D	_getVariablePosition()	0	37	9

<?php
/**
 * CodeIgniter_Sniffs_NamingConventions_ValidVariableNameSniff.
 *
 * PHP version 5
 *
 * @category  PHP
 * @package   PHP_CodeSniffer
 * @author    Thomas Ernest <thomas.ernest@baoabz.com>
 * @copyright 2010 Thomas Ernest
 * @license   http://thomas.ernest.fr/developement/php_cs/licence GNU General Public License
 * @link      http://pear.php.net/package/PHP_CodeSniffer
 */
/**
 * CodeIgniter_Sniffs_NamingConventions_ValidVariableNameSniff.
 *
 * Ensures that variable names contain only lowercase letters,
 * use underscore separators.
 * Ensures that class attribute names are prefixed with an underscore,
 * only when they are private.
 * Ensure that variable names are longer than 3 chars except those declared
 * in for loops.
 *
 * @todo Try to avoid overly long and verbose names in using property rule and
 * configuration variable to set limits. Have a look at
 * CodeIgniter_Sniffs_NamingConventions_ValidMethodNameSniff.
 * @todo Use a property rule or a configuration variable to allow users to set
 * minimum variable name length. Have a look at
 * CodeIgniter_Sniffs_Files_ClosingLocationCommentSniff and application root.
 *
 * @category  PHP
 * @package   PHP_CodeSniffer
 * @author    Thomas Ernest <thomas.ernest@baoabz.com>
 * @copyright 2010 Thomas Ernest
 * @license   http://thomas.ernest.fr/developement/php_cs/licence GNU General Public License
 * @link      http://pear.php.net/package/PHP_CodeSniffer
 */
namespace CodeIgniter\Sniffs\NamingConventions;

use PHP_CodeSniffer\Sniffs\AbstractVariableSniff;
use PHP_CodeSniffer\Files\File;

class ValidVariableNameSniff extends AbstractVariableSniff
{


    /**
     * Processes class member variables.
     *
     * @param 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)
    {
        // get variable name and properties
        $tokens = $phpcsFile->getTokens();
        $varTk = $tokens[$stackPtr];
        $varName = substr($varTk['content'], 1);
        $varProps = $phpcsFile->getMemberProperties($stackPtr);
        // check(s)
        if ( ! $this->checkLowerCase($phpcsFile, $stackPtr, $varName) ) {
            return;
        }
        if ( ! $this->checkVisibilityPrefix($phpcsFile, $stackPtr, $varName, $varProps)) {
            return;
        }
        if ( ! $this->checkLength($phpcsFile, $stackPtr, $varName)) {
            return;
        }

    }//end processMemberVar()


    /**
     * Processes normal variables.
     *
     * @param 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)
    {
        // get variable name
        $tokens = $phpcsFile->getTokens();
        $varTk = $tokens[$stackPtr];
        $varName = substr($varTk['content'], 1);
        // skip the current object variable, i.e. $this
        if (0 === strcmp($varName, 'this')) {
            return;
        }
        // check(s)
        if ( ! $this->checkLowerCase($phpcsFile, $stackPtr, $varName)) {
            return;
        }
        if ( ! $this->checkLength($phpcsFile, $stackPtr, $varName)) {
            return;
        }

    }//end processVariable()


    /**
     * Processes variables in double quoted strings.
     *
     * @param 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)
    {
        $tokens = $phpcsFile->getTokens();
        $stringTk = $tokens[$stackPtr];
        $stringString = $stringTk['content'];
        $varAt = self::_getVariablePosition($stringString, 0);
        while (false !== $varAt) {
            // get variable name
            $matches = array();
            preg_match('/^\$\{?([a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)\}?/', substr($stringString, $varAt), $matches);

This line exceeds maximum limit of 120 characters; contains 121 characters

            $varName = $matches[1];
            // check(s)
            if ( ! $this->checkLowerCase($phpcsFile, $stackPtr, $varName)) {
                return;
            }
            if ( ! $this->checkLength($phpcsFile, $stackPtr, $varName)) {
                return;
            }
            // prepare checking next variable
            $varAt = self::_getVariablePosition($stringString, $varAt + 1);
        }

    }//end processVariableInString()


    /**
     * Checks that the variable name is all in lower case, else it add an error
     * to $phpcsFile. Returns true if variable name is all in lower case, false
     * otherwise.
     *
     * @param File $phpcsFile The current file being processed.
     * @param int                  $stackPtr  The position of the current token
     *                                        in the stack passed in $tokens.
     * @param string               $varName   The name of the variable to
     *                                        procced without $, { nor }.
     *
     * @return bool true if variable name is all in lower case, false otherwise.
     */
    protected function checkLowerCase(File $phpcsFile, $stackPtr, $varName)
    {
        $isInLowerCase = true;
        if (0 !== strcmp($varName, strtolower($varName))) {
            // get the expected variable name
            $varNameWithUnderscores = preg_replace('/([A-Z])/', '_${1}', $varName);
            $expectedVarName = strtolower(ltrim($varNameWithUnderscores, '_'));
            // adapts the error message to the error case
            if (strlen($varNameWithUnderscores) > strlen($varName)) {
                $error = 'Variables should not use CamelCasing or start with a Capital.';
            } else {
                $error = 'Variables should be entirely lowercased.';
            }
            $error = $error . 'Please consider "' . $expectedVarName
                . '" instead of "' . $varName . '".';
            // adds the error and changes return value
            $phpcsFile->addError($error, $stackPtr);

The call to addError() misses a required argument $code.

            $isInLowerCase = false;
        }
        return $isInLowerCase;
    }//end checkLowerCase()

    /**
     * Checks that an underscore is used at the beginning of a variable only if
     * it is about a private variable. If it isn't a private variable, then it
     * must not be prefixed with an underscore. Returns true if $varName is
     * properly prefixed according to the variable visibility provided in
     * $varProps, false otherwise.
     *
     * @param File $phpcsFile The current file being processed.
     * @param int                  $stackPtr  The position of the current token
     *                                        in the stack passed in $tokens.
     * @param string               $varName   The name of the variable to
     *                                        procced without $, { nor }.
     * @param array                $varProps  Member variable properties like
     *                                        its visibility.
     *
     * @return bool true if variable name is prefixed with an underscore only
     * when it is about a private variable, false otherwise.
     */
    protected function checkVisibilityPrefix(File $phpcsFile, $stackPtr, $varName, $varProps)
    {
        $isVisibilityPrefixRight = true;
        $scope = $varProps['scope'];
        // If it's a private variable, it must have an underscore on the front.
        if ($scope === 'private' && $varName{0} !== '_') {
            $error = "Private variable name \"$varName\" must be prefixed with an underscore";
            $phpcsFile->addError($error, $stackPtr);

The call to addError() misses a required argument $code.

            $isVisibilityPrefixRight = false;
        } else if ($scope !== 'private' && $varName{0} === '_') {

This code seems to be duplicated across your project.

            // If it's not a private variable,
            // then it must not start with an underscore.
            if (isset ($scopeSpecified) && true === $scopeSpecified) {

The variable $scopeSpecified seems to never exist, and therefore isset should always return false. Did you maybe rename this variable?

                $error = "Public variable name \"$varName\" must not be prefixed with an underscore";
            } else {
                $error = ucfirst($scope) . " variable name \"$varName\" must not be prefixed with an underscore";
            }
            $phpcsFile->addError($error, $stackPtr);

The call to addError() misses a required argument $code.

            $isVisibilityPrefixRight = false;
        }
        return $isVisibilityPrefixRight;
    }//end checkVisibilityPrefix()

    /**
     * Checks that variable name length is not too short. Returns true, if it
     * meets minimum length requirement, false otherwise.
     *
     * A variable name is too short if it is shorter than the minimal
     * length and it isn't in the list of allowed short names nor declared in a
     * for loop (in which it would be nested).
     * The minimal length is defined in the function. It is 3 chars now.
     * The list of allowed short names is defined in the function.
     * It is case-sensitive. It contains only 'ci' now.
     *
     * @param File $phpcsFile The current file being processed.
     * @param int                  $stackPtr  The position of the current token
     *                                        in the stack passed in $tokens.
     * @param string               $varName   The name of the variable to
     *                                        procced without $, { nor }.
     *
     * @return bool false if variable name $varName is shorter than the minimal
     * length and it isn't in the list of allowed short names nor declared in a
     * for loop (in which it would be nested), otherwise true.
     */
    protected function checkLength(File $phpcsFile, $stackPtr, $varName)
    {
        $minLength = 3;
        $allowedShortName = array('ci');

        $isLengthRight = true;
        // cleans variable name
        $varName = ltrim($varName, '_');
        if (strlen($varName) <= $minLength) {
            // skips adding an error, if it is a specific variable name
            if (in_array($varName, $allowedShortName)) {
                return $isLengthRight;
            }
            // skips adding an error, if the variable is in a for loop
            if (false !== self::_isInForLoop($phpcsFile, $stackPtr, $varName)) {
                return $isLengthRight;
            }
            // adds the error message finally
            $error = 'Very short'
                . (
                    $minLength > 0 ?
                    ' (i.e. less than ' . ($minLength + 1) . ' chars)'
                    : ''
                )
                . ', non-word variables like "' . $varName
                . '" should only be used as iterators in for() loops.';
            $phpcsFile->addError($error, $stackPtr);

The call to addError() misses a required argument $code.

            $isLengthRight = false;
        }
        return $isLengthRight;
    }//end checkLength()

    /**
     * Returns the position of closest previous T_FOR, if token associated with
     * $stackPtr in $phpcsFile is in a for loop, otherwise false.
     *
     * @param File $phpcsFile The current file being processed.
     * @param int                  $stackPtr  The position of the current token
     *                                        in the stack passed in $tokens.
     * @param string               $varName   The name of the variable to
     *                                        procced without $, { nor }.
     *
     * @return int|bool Position of T_FOR if token associated with $stackPtr in
     *                  $phpcsFile is in the head of a for loop, otherwise false.
     */
    private static function _isInForLoop(File $phpcsFile, $stackPtr, $varName)
    {
        $keepLookingFromPtr = $stackPtr;
        while (false !== $keepLookingFromPtr) {
            // looks if it is in (head or body) of a for loop
            $forPtr = self::_isInForLoopHead($phpcsFile, $keepLookingFromPtr);

It seems like $keepLookingFromPtr can also be of type boolean; however, CodeIgniter\Sniffs\NamingConventions\ValidVariableNameSniff::_isInForLoopHead() does only seem to accept integer, maybe add an additional type check?

            if (false === $forPtr) {
                $forPtr = self::_isInForLoopBody($phpcsFile, $keepLookingFromPtr);

It seems like $keepLookingFromPtr can also be of type boolean; however, CodeIgniter\Sniffs\NamingConventions\ValidVariableNameSniff::_isInForLoopBody() does only seem to accept integer, maybe add an additional type check?

            }
            // checks if it is declared in here and prepares next step
            if (false !== $forPtr) {
                if (false !== self::_isDeclaredInForLoop($phpcsFile, $forPtr, $varName)) {

It seems like $forPtr can also be of type boolean; however, CodeIgniter\Sniffs\NamingConventions\ValidVariableNameSniff::_isDeclaredInForLoop() does only seem to accept integer, maybe add an additional type check?

                    return $forPtr;
                }
                $keepLookingFromPtr = $forPtr;
            } else {
                $keepLookingFromPtr = false;
            }
        }
        return false;
    }//end _isInForLoop()

    /**
     * Returns the position of closest previous T_FOR, if token associated with
     * $stackPtr in $phpcsFile is in the head of a for loop, otherwise false.
     * The head is the code placed between parenthesis next to the key word
     * 'for' : for (<loop_head>) {<loop_body>}.
     *
     * @param File $phpcsFile The current file being processed.
     * @param int                  $stackPtr  The position of the current token
     *                                        in the stack passed in $tokens.
     *
     * @return int|bool Position of T_FOR if token associated with $stackPtr in
     *                  $phpcsFile is in the head of a for loop, otherwise false.
     */
    private static function _isInForLoopHead(File $phpcsFile, $stackPtr)
    {
        $isInForLoop = false;
        $tokens = $phpcsFile->getTokens();
        $currentTk = $tokens[$stackPtr];
        if (array_key_exists('nested_parenthesis', $currentTk)) {
            $nestedParenthesis = $currentTk['nested_parenthesis'];
            foreach ( $nestedParenthesis as $openParPtr => $closeParPtr) {
                $nonWhitspacePtr = $phpcsFile->findPrevious(
                    array(T_WHITESPACE),
                    $openParPtr - 1,
                    null,
                    true,
                    null,
                    true
                );
                if (false !== $nonWhitspacePtr) {
                    $isFor = T_FOR === $tokens[$nonWhitspacePtr]['code'];
                    if ($isFor) {
                        $isInForLoop = $nonWhitspacePtr;
                        break;
                    }
                }
            }
        }
        return $isInForLoop;
    }//end _isInForLoopHead()

    /**
     * Returns the position of closest previous T_FOR, if token associated with
     * $stackPtr in $phpcsFile is in the body of a for loop, otherwise false.
     * The body are the instructions placed after parenthesis of a 'for'
     * declaration, enclosed with curly brackets usually.
     * 'for' : for (<loop_head>) {<loop_body>}.
     *
     * @param File $phpcsFile The current file being processed.
     * @param int                  $stackPtr  The position of the current token
     *                                        in the stack passed in $tokens.
     *
     * @return int|bool Position of T_FOR if token associated with $stackPtr in
     *                  $phpcsFile is in the body of a for loop, otherwise false.
     */
    private static function _isInForLoopBody(File $phpcsFile, $stackPtr)
    {
        $isInForLoop = false;

$isInForLoop is not used, you could remove the assignment.

        $tokens = $phpcsFile->getTokens();
        // get englobing hierarchy
        $parentPtrAndCode = $tokens[$stackPtr]['conditions'];
        krsort($parentPtrAndCode);

        // looks for a for loop having a body not enclosed with curly brackets,
        // which involves that its body contains only one instruction.
        if (is_array($parentPtrAndCode) && ! empty($parentPtrAndCode)) {
            $parentCode = reset($parentPtrAndCode);
            $parentPtr = key($parentPtrAndCode);
            $openBracketPtr = $tokens[$parentPtr]['scope_opener'];
        } else {
            $parentCode = 0;
            $parentPtr = 0;
            $openBracketPtr = 0;
        }
        $openResearchScopePtr = $stackPtr;
        // recursive search, since a for statement may englobe other inline
        // control statement or may be near to function calls, etc...
        while (false !== $openResearchScopePtr) {
            $closeParPtr = $phpcsFile->findPrevious(
                array(T_CLOSE_PARENTHESIS),
                $openResearchScopePtr,
                null,
                false,
                null,
                true
            );
            // is there a closing parenthesis with a control statement before
            // the previous instruction ?
            if (false !== $closeParPtr) {
                // is there no opening curly bracket specific to
                // set of instructions, between the closing parenthesis
                // and the current token ?
                if ($openBracketPtr < $closeParPtr) {
                    // starts the search from the token before the closing
                    // parenthesis, if it isn't a for statement
                    $openResearchScopePtr = $closeParPtr - 1;
                    // is this parenthesis associated with a for statement ?
                    $closeParenthesisTk = $tokens[$closeParPtr];
                    if (array_key_exists('parenthesis_owner', $closeParenthesisTk)) {
                        $mayBeForPtr = $closeParenthesisTk['parenthesis_owner'];
                        $mayBeForTk = $tokens[$mayBeForPtr];
                        if (T_FOR === $mayBeForTk['code']) {
                            return $mayBeForPtr;
                        }
                    }
                } else {
                    // if it is about a for loop, don't go further
                    // and detect it after one more loop execution, do it now
                    if (T_FOR === $parentCode) {
                        return $parentPtr;
                    }
                    // starts the search from the token before the one
                    // englobing the current statement
                    $openResearchScopePtr = $parentPtr - 1;
                    // re-initialize variables about the englobing structure
                    if (is_array($parentPtrAndCode)) {
                        $parentCode = next($parentPtrAndCode);
                        $parentPtr = key($parentPtrAndCode);
                        $openBracketPtr = $tokens[$parentPtr]['scope_opener'];
                    }
                }
            } else {
                $openResearchScopePtr = false;
            }
        }
        // looks for a for loop having a body enclosed with curly brackets
        foreach ($parentPtrAndCode as $parentPtr => $parentCode) {
            if (T_FOR === $parentCode) {
                return $parentPtr;
            }
        }
        return false;
    }//end _isInForLoopBody()

    /**
     * Returns true if a variable declared in the head of the for loop pointed
     * by $forPtr in file $phpcsFile has the name $varName.
     *
     * @param File $phpcsFile The current file being processed.
     * @param int                  $forPtr    The position of the 'for' token
     *                                        in the stack passed in $tokens.
     * @param string               $varName   The name of the variable to
     *                                        procced without $, { nor }.
     *
     * @return int|bool true if a variable declared in the head of the for loop
     * pointed by $forPtr in file $phpcsFile has the name $varName.
     */
    private static function _isDeclaredInForLoop(File $phpcsFile, $forPtr, $varName)
    {
        $isDeclaredInFor = false;
        $tokens = $phpcsFile->getTokens();
        $forVarPtrs = self::_getVarDeclaredInFor($phpcsFile, $forPtr);
        foreach ($forVarPtrs as $forVarPtr) {
            $forVarTk = $tokens[$forVarPtr];
            // get variable name
            $matches = array();
            preg_match('/^\$\{?([a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)\}?/', $forVarTk['content'], $matches);
            $forVarName = $matches[1];
            if (0 === strcmp($forVarName, $varName)) {
                $isDeclaredInFor = $forVarPtr;
                break;
            }
        }
        return $isDeclaredInFor;
    }//end _isDeclaredInForLoop()

    /**
     * Returns list of pointers to variables declared in for loop associated to
     * $forPtr in file $phpcsFile.
     *
     * All pointers in the result list are pointing to token with code
     * T_VARIABLE. An exception is raised, if $forPtr doesn't point a token with
     * code T_FOR.
     *
     * @param File $phpcsFile The current file being processed.
     * @param int                  $forPtr    The position of the current token
     *                                        in the stack passed in $tokens.
     *
     * @return array List of pointers to variables declared in for loop $forPtr.
     */
    private static function _getVarDeclaredInFor(File $phpcsFile, $forPtr)
    {
        $tokens = $phpcsFile->getTokens();
        $forTk = $tokens[$forPtr];
        if (T_FOR !== $forTk['code']) {
            throw new PHP_CodeSniffer_Exception('$forPtr must be of type T_FOR');
        }
        $openParPtr = $forTk['parenthesis_opener'];
        $openParenthesisTk = $tokens[$openParPtr];

$openParenthesisTk is not used, you could remove the assignment.

        $endOfDeclPtr = $phpcsFile->findNext(array(T_SEMICOLON), $openParPtr);
        $forVarPtrs = array();
        $varPtr = $phpcsFile->findNext(
            array(T_VARIABLE),
            $openParPtr + 1,
            $endOfDeclPtr

It seems like $endOfDeclPtr defined by $phpcsFile->findNext(array(T_SEMICOLON), $openParPtr) on line 492 can also be of type false; however, PHP_CodeSniffer\Files\File::findNext() does only seem to accept integer|null, did you maybe forget to handle an error condition?

        );
        while (false !== $varPtr) {
            $forVarPtrs [] = $varPtr;
            $varPtr = $phpcsFile->findNext(
                array(T_VARIABLE),
                $varPtr + 1,
                $endOfDeclPtr

It seems like $endOfDeclPtr defined by $phpcsFile->findNext(array(T_SEMICOLON), $openParPtr) on line 492 can also be of type false; however, PHP_CodeSniffer\Files\File::findNext() does only seem to accept integer|null, did you maybe forget to handle an error condition?

            );
        }
        return $forVarPtrs;
    }//end _getVarDeclaredInFor()

    /**
     * Returns the position of first occurrence of a PHP variable starting with
     * $ in $haystack from $offset.
     *
     * @param string $haystack The string to search in.
     * @param int    $offset   The optional offset parameter allows you to
     *                         specify which character in haystack to start
     *                         searching. The returned position is still
     *                         relative to the beginning of haystack.
     *
     * @return mixed The position as an integer
     *               or the boolean false, if no variable is found.
     */
    private static function _getVariablePosition($haystack, $offset = 0)
    {
        $var_starts_at = strpos($haystack, '$', $offset);
        $is_a_var = false;
        while (false !== $var_starts_at && ! $is_a_var) {
            // makes sure that $ is used for a variable and not as a symbol,
            // if $ is protected with the escape char, then it is a symbol.
            if (0 !== strcmp($haystack[$var_starts_at - 1], '\\')) {
                if (0 === strcmp($haystack[$var_starts_at + 1], '{')) {
                    // there is an opening brace in the right place
                    // so it looks for the closing brace in the right place
                    $hsChunk2 = substr($haystack, $var_starts_at + 2);
                    if (1 === preg_match('/^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*\}/', $hsChunk2)) {
                        $is_a_var = true;
                    }
                } else {
                    $hsChunk1 = substr($haystack, $var_starts_at + 1);
                    if (1 === preg_match('/^[a-zA-Z_\x7f-\xff]/', $hsChunk1)) {
                        // $ is used for a variable and not as a symbol,
                        // since what follows $ matchs the definition of
                        // a variable label for PHP.
                        $is_a_var = true;
                    }
                }
            }
            // update $var_starts_at for the next variable
            // only if no variable was found, since it is returned otherwise.
            if ( ! $is_a_var) {
                $var_starts_at = strpos($haystack, '$', $var_starts_at + 1);
            }
        }
        if ($is_a_var) {
            return $var_starts_at;
        } else {
            return false;
        }
    }//end _getVariablePosition()
}//end class

?>

It is not recommended to use PHP's closing tag ?> in files other than templates.

As per coding style, files should not end with a newline character.