NewHeredocInitializeSniff::process() - Code Metrics - Inspection of "PHP 5.3: Add new sniff to detect heredoc initializ..." - wimg/PHPCompatibility - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#391)

by Juliette

created 2017-04-15 18:55 UTC

NewHeredocInitializeSniff::process() C

↳ Parent: NewHeredocInitializeSniff

Complexity

Conditions	15
Paths	10

Size

Total Lines	65
Code Lines	28

Duplication

Lines	35
Ratio	53.85 %

Importance

Changes

Metric	Value
dl	35
loc	65
rs	5.9352
c	0
b	0
f	0
cc	15
eloc	28
nc	10
nop	2

How to fix Long Method Complexity

<?php
/**
 * PHPCompatibility_Sniffs_PHP_NewHeredocInitializeSniff.
 *
 * PHP version 5.3
 *
 * @category PHP
 * @package  PHPCompatibility
 * @author   Juliette Reinders Folmer <[email protected]>
 */

/**
 * PHPCompatibility_Sniffs_PHP_NewHeredocInitializeSniff.
 *
 * As of PHP 5.3.0, it's possible to initialize static variables and class
 * properties/constants using the Heredoc syntax.
 *
 * PHP version 5.3
 *
 * @category PHP
 * @package  PHPCompatibility
 * @author   Juliette Reinders Folmer <[email protected]>
 */
class PHPCompatibility_Sniffs_PHP_NewHeredocInitializeSniff extends PHPCompatibility_Sniff
namespace YourVendor;

class YourClass { }
{

    /**
     * Returns an array of tokens this test wants to listen for.
     *
     * @return array
     */
    public function register()
    {
        return array(T_START_HEREDOC);
    }

    /**
     * Processes this test, when one of its tokens is encountered.
     *
     * @param PHP_CodeSniffer_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(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
    {
        if ($this->supportsBelow('5.2') !== true) {
            return;
        }

        $tokens = $phpcsFile->getTokens();

        $equalSign = $phpcsFile->findPrevious(PHP_CodeSniffer_Tokens::$emptyTokens, ($stackPtr - 1), null, true, null, true);
        if ($equalSign === false || $tokens[$equalSign]['code'] !== T_EQUAL) {
            // Not an assignment.
            return;
        }

        $prevNonEmpty = $phpcsFile->findPrevious(PHP_CodeSniffer_Tokens::$emptyTokens, ($equalSign - 1), null, true, null, true);
        if ($prevNonEmpty === false ||
            ($tokens[$prevNonEmpty]['code'] !== T_VARIABLE && $tokens[$prevNonEmpty]['code'] !== T_STRING)
        ) {
            // Not a variable or constant assignment.
            return;
        }


        switch ($tokens[$prevNonEmpty]['type']) {
            /*
             * Check class constant assignments.
             */
            case 'T_STRING':

                // Walk back to check for the const keyword.
                $constPtr = $phpcsFile->findPrevious(PHP_CodeSniffer_Tokens::$emptyTokens, ($prevNonEmpty - 1), null, true, null, true);
                if ($constPtr === false || $tokens[$constPtr]['code'] !== T_CONST) {
                    // Not a constant assignment.
                    return;
                }

                if ($this->isClassConstant($phpcsFile, $constPtr) === true) {
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                    $this->throwError($phpcsFile, $stackPtr, 'const');
                }
                return;

            case 'T_VARIABLE':

                /*
                 * Check class property assignments.
                 */
                if ($this->isClassProperty($phpcsFile, $prevNonEmpty) === true) {
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                    $this->throwError($phpcsFile, $stackPtr, 'property');
                }

                /*
                 * Check static variable assignments.
                 */
                else {
                    // Walk back to check this is a static variable `static $var =`.
                    $staticPtr = $phpcsFile->findPrevious(PHP_CodeSniffer_Tokens::$emptyTokens, ($prevNonEmpty - 1), null, true, null, true);
                    if ($staticPtr === false || $tokens[$staticPtr]['code'] !== T_STATIC) {
                        // Not a static variable assignment.
                        return;
                    }

                    // Still here ? Then we have a static variable assignment
                    $this->throwError($phpcsFile, $stackPtr, 'staticvar');
                }
                return;
        }
    }


    /**
     * Throw an error if a non-static value is found.
     *
     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
     * @param int                  $stackPtr  The position of the token to link the error to.
     * @param string               $type      Type of usage found.
     *
     * @return void
     */
    protected function throwError(PHP_CodeSniffer_File $phpcsFile, $stackPtr, $type)
    {
        switch($type) {
            case 'const':
                $phrase = 'class constants';
                break;

            case 'property':
                $phrase = 'class properties';
                break;

            case 'staticvar':
                $phrase = 'static variables';
                break;

            default:
                $phrase = '';
                break;
        }

        $errorCode = $this->stringToErrorCode($type) . 'Found';

        $phpcsFile->addError(
            'Initializing %s using the Heredoc syntax was not supported in PHP 5.2 or earlier',
            $stackPtr,
            $errorCode,
            array($phrase)
        );
    }

}


1		<?php
2		/**
3		* PHPCompatibility_Sniffs_PHP_NewHeredocInitializeSniff.
4		*
5		* PHP version 5.3
6		*
7		* @category PHP
8		* @package PHPCompatibility
9		* @author Juliette Reinders Folmer <[email protected]>
10		*/
11
12		/**
13		* PHPCompatibility_Sniffs_PHP_NewHeredocInitializeSniff.
14		*
15		* As of PHP 5.3.0, it's possible to initialize static variables and class
16		* properties/constants using the Heredoc syntax.
17		*
18		* PHP version 5.3
19		*
20		* @category PHP
21		* @package PHPCompatibility
22		* @author Juliette Reinders Folmer <[email protected]>
23		*/
24		class PHPCompatibility_Sniffs_PHP_NewHeredocInitializeSniff extends PHPCompatibility_Sniff
		0 ignored issues – show Coding Style Compatibility introduced 2017-04-03 10:40 UTC by Report Bug Copy Issue Report PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions. You can fix this by adding a namespace to your class: namespace YourVendor; class YourClass { } When choosing a vendor namespace, try to pick something that is not too generic to avoid conflicts with other libraries. Loading history...
25		{
26
27		/**
28		* Returns an array of tokens this test wants to listen for.
29		*
30		* @return array
31		*/
32		public function register()
33		{
34		return array(T_START_HEREDOC);
35		}
36
37		/**
38		* Processes this test, when one of its tokens is encountered.
39		*
40		* @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
41		* @param int $stackPtr The position of the current token in the
42		* stack passed in $tokens.
43		*
44		* @return void
45		*/
46		public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
47		{
48		if ($this->supportsBelow('5.2') !== true) {
49		return;
50		}
51
52		$tokens = $phpcsFile->getTokens();
53
54		$equalSign = $phpcsFile->findPrevious(PHP_CodeSniffer_Tokens::$emptyTokens, ($stackPtr - 1), null, true, null, true);
55		if ($equalSign === false \|\| $tokens[$equalSign]['code'] !== T_EQUAL) {
56		// Not an assignment.
57		return;
58		}
59
60		$prevNonEmpty = $phpcsFile->findPrevious(PHP_CodeSniffer_Tokens::$emptyTokens, ($equalSign - 1), null, true, null, true);
61		if ($prevNonEmpty === false \|\|
62		($tokens[$prevNonEmpty]['code'] !== T_VARIABLE && $tokens[$prevNonEmpty]['code'] !== T_STRING)
63		) {
64		// Not a variable or constant assignment.
65		return;
66		}
67
68
69		switch ($tokens[$prevNonEmpty]['type']) {
70		/*
71		* Check class constant assignments.
72		*/
73	View Code Duplication	case 'T_STRING':
		1 ignored issue – show Duplication introduced 2017-04-15 18:57 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
74		// Walk back to check for the const keyword.
75		$constPtr = $phpcsFile->findPrevious(PHP_CodeSniffer_Tokens::$emptyTokens, ($prevNonEmpty - 1), null, true, null, true);
76		if ($constPtr === false \|\| $tokens[$constPtr]['code'] !== T_CONST) {
77		// Not a constant assignment.
78		return;
79		}
80
81		if ($this->isClassConstant($phpcsFile, $constPtr) === true) {
		0 ignored issues – show Bug introduced 2017-04-15 18:57 UTC by Report Bug Copy Issue Report It seems like `$constPtr` defined by `$phpcsFile->findPrevious...null, true, null, true)` on line `75` can also be of type `boolean`; however, `PHPCompatibility_Sniff::isClassConstant()` does only seem to accept `integer`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
82		$this->throwError($phpcsFile, $stackPtr, 'const');
83		}
84		return;
85
86	View Code Duplication	case 'T_VARIABLE':
		1 ignored issue – show Duplication introduced 2017-04-15 18:57 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
87		/*
88		* Check class property assignments.
89		*/
90		if ($this->isClassProperty($phpcsFile, $prevNonEmpty) === true) {
		0 ignored issues – show Bug introduced 2017-04-15 18:57 UTC by Report Bug Copy Issue Report It seems like `$prevNonEmpty` defined by `$phpcsFile->findPrevious...null, true, null, true)` on line `60` can also be of type `boolean`; however, `PHPCompatibility_Sniff::isClassProperty()` does only seem to accept `integer`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
91		$this->throwError($phpcsFile, $stackPtr, 'property');
92		}
93
94		/*
95		* Check static variable assignments.
96		*/
97		else {
98		// Walk back to check this is a static variable `static $var =`.
99		$staticPtr = $phpcsFile->findPrevious(PHP_CodeSniffer_Tokens::$emptyTokens, ($prevNonEmpty - 1), null, true, null, true);
100		if ($staticPtr === false \|\| $tokens[$staticPtr]['code'] !== T_STATIC) {
101		// Not a static variable assignment.
102		return;
103		}
104
105		// Still here ? Then we have a static variable assignment
106		$this->throwError($phpcsFile, $stackPtr, 'staticvar');
107		}
108		return;
109		}
110		}
111
112
113		/**
114		* Throw an error if a non-static value is found.
115		*
116		* @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
117		* @param int $stackPtr The position of the token to link the error to.
118		* @param string $type Type of usage found.
119		*
120		* @return void
121		*/
122		protected function throwError(PHP_CodeSniffer_File $phpcsFile, $stackPtr, $type)
123		{
124		switch($type) {
125		case 'const':
126		$phrase = 'class constants';
127		break;
128
129		case 'property':
130		$phrase = 'class properties';
131		break;
132
133		case 'staticvar':
134		$phrase = 'static variables';
135		break;
136
137		default:
138		$phrase = '';
139		break;
140		}
141
142		$errorCode = $this->stringToErrorCode($type) . 'Found';
143
144		$phpcsFile->addError(
145		'Initializing %s using the Heredoc syntax was not supported in PHP 5.2 or earlier',
146		$stackPtr,
147		$errorCode,
148		array($phrase)
149		);
150		}
151
152		}
153

wimg / PHPCompatibility

Pull Request — master (#391)

NewHeredocInitializeSniff::process() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like