PHPCompatibility_Sniff::supportsAbove() - Code Metrics - Inspection of "Add *a lot* more new function parameters to the `N..." - wimg/PHPCompatibility - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#164)

by Juliette

created 2016-08-13 14:31 UTC

PHPCompatibility_Sniff::supportsAbove() A

↳ Parent: PHPCompatibility_Sniff

Complexity

Conditions	3
Paths	2

Size

Total Lines	13
Code Lines	8

Duplication

Lines	13
Ratio	100 %

Importance

Changes	6
Bugs	1	Features	0

Metric	Value
cc	3
eloc	8
c	6
b	1
f	0
nc	2
nop	1
dl	13
loc	13
rs	9.4285

<?php
/**
 * PHPCompatibility_Sniff.
 *
 * PHP version 5.6
 *
 * @category  PHP
 * @package   PHPCompatibility
 * @author    Wim Godden <[email protected]>
 * @copyright 2014 Cu.be Solutions bvba
 */

/**
 * PHPCompatibility_Sniff.
 *
 * @category  PHP
 * @package   PHPCompatibility
 * @author    Wim Godden <[email protected]>
 * @version   1.1.0
 * @copyright 2014 Cu.be Solutions bvba
 */
abstract class PHPCompatibility_Sniff implements PHP_CodeSniffer_Sniff
namespace YourVendor;

class YourClass { }
{

/* The testVersion configuration variable may be in any of the following formats:
 * 1) Omitted/empty, in which case no version is specified.  This effectively
 *    disables all the checks provided by this standard.
 * 2) A single PHP version number, e.g. "5.4" in which case the standard checks that
 *    the code will run on that version of PHP (no deprecated features or newer
 *    features being used).
 * 3) A range, e.g. "5.0-5.5", in which case the standard checks the code will run
 *    on all PHP versions in that range, and that it doesn't use any features that
 *    were deprecated by the final version in the list, or which were not available
 *    for the first version in the list.
 * PHP version numbers should always be in Major.Minor format.  Both "5", "5.3.2"
 * would be treated as invalid, and ignored.
 * This standard doesn't support checking against PHP4, so the minimum version that
 * is recognised is "5.0".
 */

    private function getTestVersion()
    {
        /**
         * var $arrTestVersions will hold an array containing min/max version of PHP
         *   that we are checking against (see above).  If only a single version
         *   number is specified, then this is used as both the min and max.
         */
        static $arrTestVersions = array();

        $testVersion = trim(PHP_CodeSniffer::getConfigData('testVersion'));

        if (!isset($arrTestVersions[$testVersion]) && !empty($testVersion)) {

            $arrTestVersions[$testVersion] = array(null, null);
            if (preg_match('/^\d+\.\d+$/', $testVersion)) {
                $arrTestVersions[$testVersion] = array($testVersion, $testVersion);
            }
            elseif (preg_match('/^(\d+\.\d+)\s*-\s*(\d+\.\d+)$/', $testVersion,
                               $matches))
            {
                if (version_compare($matches[1], $matches[2], '>')) {
                    trigger_error("Invalid range in testVersion setting: '"
                                  . $testVersion . "'", E_USER_WARNING);
                }
                else {
                    $arrTestVersions[$testVersion] = array($matches[1], $matches[2]);
                }
            }
            elseif (!$testVersion == '') {
                trigger_error("Invalid testVersion setting: '" . $testVersion
                              . "'", E_USER_WARNING);
            }
        }

        if (isset($arrTestVersions[$testVersion])) {
            return $arrTestVersions[$testVersion];
        }
        else {
			return array(null, null);
        }
    }

    public function supportsAbove($phpVersion)

    {
        $testVersion = $this->getTestVersion();
        $testVersion = $testVersion[1];

        if (is_null($testVersion)
            || version_compare($testVersion, $phpVersion) >= 0
        ) {
            return true;
        } else {
            return false;
        }
    }//end supportsAbove()

    public function supportsBelow($phpVersion)

    {
        $testVersion = $this->getTestVersion();
        $testVersion = $testVersion[0];

        if (!is_null($testVersion)
            && version_compare($testVersion, $phpVersion) <= 0
        ) {
            return true;
        } else {
            return false;
        }
    }//end supportsBelow()

    /**
     * Returns the name(s) of the interface(s) that the specified class implements.
     *
     * Returns FALSE on error or if there are no implemented interface names.
     *
     * {@internal Duplicate of same method as introduced in PHPCS 2.7.
     * Once the minimum supported PHPCS version for this sniff library goes beyond
     * that, this method can be removed and call to it replaced with
     * `$phpcsFile->findImplementedInterfaceNames($stackPtr)` calls.}}
     *
     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
     * @param int                  $stackPtr  The position of the class token.
     *
     * @return array|false
     */
    public function findImplementedInterfaceNames($phpcsFile, $stackPtr)
    {
        $tokens = $phpcsFile->getTokens();

        // Check for the existence of the token.
        if (isset($tokens[$stackPtr]) === false) {
            return false;
        }

        if ($tokens[$stackPtr]['code'] !== T_CLASS) {
            return false;
        }

        if (isset($tokens[$stackPtr]['scope_closer']) === false) {
            return false;
        }

        $classOpenerIndex = $tokens[$stackPtr]['scope_opener'];
        $implementsIndex  = $phpcsFile->findNext(T_IMPLEMENTS, $stackPtr, $classOpenerIndex);
        if ($implementsIndex === false) {
            return false;
        }

        $find = array(
                 T_NS_SEPARATOR,
                 T_STRING,
                 T_WHITESPACE,
                 T_COMMA,
                );

        $end  = $phpcsFile->findNext($find, ($implementsIndex + 1), ($classOpenerIndex + 1), true);
        $name = $phpcsFile->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()


    /**
     * Checks if a function call has parameters.
     *
     * Expects to be passed the T_STRING stack pointer for the function call.
     * If passed a T_STRING which is *not* a function call, the behaviour is unreliable.
     *
     * @link https://github.com/wimg/PHPCompatibility/issues/120
     * @link https://github.com/wimg/PHPCompatibility/issues/152
     *
     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
     * @param int                  $stackPtr  The position of the function call token.
     *
     * @return bool
     */
    public function doesFunctionCallHaveParameters(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
    {
        $tokens = $phpcsFile->getTokens();

        // Check for the existence of the token.
        if (isset($tokens[$stackPtr]) === false) {
            return false;
        }

        if ($tokens[$stackPtr]['code'] !== T_STRING) {
            return false;
        }

        // Next non-empty token should be the open parenthesis.
        $openParenthesis = $phpcsFile->findNext(PHP_CodeSniffer_Tokens::$emptyTokens, $stackPtr + 1, null, true, null, true);
        if ($openParenthesis === false || $tokens[$openParenthesis]['code'] !== T_OPEN_PARENTHESIS) {
            return false;
        }

        if (isset($tokens[$openParenthesis]['parenthesis_closer']) === false) {
            return false;
        }

        $closeParenthesis = $tokens[$openParenthesis]['parenthesis_closer'];
        $nextNonEmpty     = $phpcsFile->findNext(PHP_CodeSniffer_Tokens::$emptyTokens, $openParenthesis + 1, $closeParenthesis + 1, true);

        if ($nextNonEmpty === $closeParenthesis) {
            // No parameters.
            return false;
        }

        return true;
    }


    /**
     * Count the number of parameters a function call has been passed.
     *
     * Expects to be passed the T_STRING stack pointer for the function call.
     * If passed a T_STRING which is *not* a function call, the behaviour is unreliable.
     *
     * @link https://github.com/wimg/PHPCompatibility/issues/111
     * @link https://github.com/wimg/PHPCompatibility/issues/114
     * @link https://github.com/wimg/PHPCompatibility/issues/151
     *
     * @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
     * @param int                  $stackPtr  The position of the function call token.
     *
     * @return int
     */
    public function getFunctionCallParameterCount(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
    {
        if ($this->doesFunctionCallHaveParameters($phpcsFile, $stackPtr) === false) {
            return 0;
        }

        // Ok, we know we have a T_STRING with parameters and valid open & close parenthesis.
        $tokens = $phpcsFile->getTokens();

        $openParenthesis = $phpcsFile->findNext(PHP_CodeSniffer_Tokens::$emptyTokens, $stackPtr + 1, null, true, null, true);
        $closeParenthesis = $tokens[$openParenthesis]['parenthesis_closer'];

        // Which nesting level is the one we are interested in ?
        $nestedParenthesisCount = 1;
        if (isset($tokens[$openParenthesis]['nested_parenthesis'])) {
            $nestedParenthesisCount = count($tokens[$openParenthesis]['nested_parenthesis']) + 1;
        }

        $nextComma = $openParenthesis;
        $cnt = 0;
        while ($nextComma = $phpcsFile->findNext(array(T_COMMA, T_CLOSE_PARENTHESIS), $nextComma + 1, $closeParenthesis + 1)) {
            // Ignore comma's at a lower nesting level.
            if (
                $tokens[$nextComma]['type'] == 'T_COMMA'
                &&
                isset($tokens[$nextComma]['nested_parenthesis'])
                &&
                count($tokens[$nextComma]['nested_parenthesis']) != $nestedParenthesisCount
            ) {
                continue;
            }

            // Ignore closing parenthesis if not 'ours'.
            if ($tokens[$nextComma]['type'] == 'T_CLOSE_PARENTHESIS' && $nextComma != $closeParenthesis) {
                continue;
            }

            $cnt++;
        }

        return $cnt;
    }

}//end class


1		<?php
2		/**
3		* PHPCompatibility_Sniff.
4		*
5		* PHP version 5.6
6		*
7		* @category PHP
8		* @package PHPCompatibility
9		* @author Wim Godden <[email protected]>
10		* @copyright 2014 Cu.be Solutions bvba
11		*/
12
13		/**
14		* PHPCompatibility_Sniff.
15		*
16		* @category PHP
17		* @package PHPCompatibility
18		* @author Wim Godden <[email protected]>
19		* @version 1.1.0
20		* @copyright 2014 Cu.be Solutions bvba
21		*/
22		abstract class PHPCompatibility_Sniff implements PHP_CodeSniffer_Sniff
		0 ignored issues – show Coding Style Compatibility introduced 2016-08-04 22:56 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...
23		{
24
25		/* The testVersion configuration variable may be in any of the following formats:
26		* 1) Omitted/empty, in which case no version is specified. This effectively
27		* disables all the checks provided by this standard.
28		* 2) A single PHP version number, e.g. "5.4" in which case the standard checks that
29		* the code will run on that version of PHP (no deprecated features or newer
30		* features being used).
31		* 3) A range, e.g. "5.0-5.5", in which case the standard checks the code will run
32		* on all PHP versions in that range, and that it doesn't use any features that
33		* were deprecated by the final version in the list, or which were not available
34		* for the first version in the list.
35		* PHP version numbers should always be in Major.Minor format. Both "5", "5.3.2"
36		* would be treated as invalid, and ignored.
37		* This standard doesn't support checking against PHP4, so the minimum version that
38		* is recognised is "5.0".
39		*/
40
41		private function getTestVersion()
42		{
43		/**
44		* var $arrTestVersions will hold an array containing min/max version of PHP
45		* that we are checking against (see above). If only a single version
46		* number is specified, then this is used as both the min and max.
47		*/
48		static $arrTestVersions = array();
49
50		$testVersion = trim(PHP_CodeSniffer::getConfigData('testVersion'));
51
52		if (!isset($arrTestVersions[$testVersion]) && !empty($testVersion)) {
53
54		$arrTestVersions[$testVersion] = array(null, null);
55		if (preg_match('/^\d+\.\d+$/', $testVersion)) {
56		$arrTestVersions[$testVersion] = array($testVersion, $testVersion);
57		}
58		elseif (preg_match('/^(\d+\.\d+)\s-\s(\d+\.\d+)$/', $testVersion,
59		$matches))
60		{
61		if (version_compare($matches[1], $matches[2], '>')) {
62		trigger_error("Invalid range in testVersion setting: '"
63		. $testVersion . "'", E_USER_WARNING);
64		}
65		else {
66		$arrTestVersions[$testVersion] = array($matches[1], $matches[2]);
67		}
68		}
69		elseif (!$testVersion == '') {
70		trigger_error("Invalid testVersion setting: '" . $testVersion
71		. "'", E_USER_WARNING);
72		}
73		}
74
75		if (isset($arrTestVersions[$testVersion])) {
76		return $arrTestVersions[$testVersion];
77		}
78		else {
79		return array(null, null);
80		}
81		}
82
83	View Code Duplication	public function supportsAbove($phpVersion)
		0 ignored issues – show Duplication introduced 2015-11-20 23:31 UTC by Report Bug Copy Issue Report This method seems to be duplicated in 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...
84		{
85		$testVersion = $this->getTestVersion();
86		$testVersion = $testVersion[1];
87
88		if (is_null($testVersion)
89		\|\| version_compare($testVersion, $phpVersion) >= 0
90		) {
91		return true;
92		} else {
93		return false;
94		}
95		}//end supportsAbove()
96
97	View Code Duplication	public function supportsBelow($phpVersion)
		0 ignored issues – show Duplication introduced 2015-11-20 23:31 UTC by Report Bug Copy Issue Report This method seems to be duplicated in 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...
98		{
99		$testVersion = $this->getTestVersion();
100		$testVersion = $testVersion[0];
101
102		if (!is_null($testVersion)
103		&& version_compare($testVersion, $phpVersion) <= 0
104		) {
105		return true;
106		} else {
107		return false;
108		}
109		}//end supportsBelow()
110
111		/**
112		* Returns the name(s) of the interface(s) that the specified class implements.
113		*
114		* Returns FALSE on error or if there are no implemented interface names.
115		*
116		* {@internal Duplicate of same method as introduced in PHPCS 2.7.
117		* Once the minimum supported PHPCS version for this sniff library goes beyond
118		* that, this method can be removed and call to it replaced with
119		* `$phpcsFile->findImplementedInterfaceNames($stackPtr)` calls.}}
120		*
121		* @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
122		* @param int $stackPtr The position of the class token.
123		*
124		* @return array\|false
125		*/
126		public function findImplementedInterfaceNames($phpcsFile, $stackPtr)
127		{
128		$tokens = $phpcsFile->getTokens();
129
130		// Check for the existence of the token.
131		if (isset($tokens[$stackPtr]) === false) {
132		return false;
133		}
134
135		if ($tokens[$stackPtr]['code'] !== T_CLASS) {
136		return false;
137		}
138
139		if (isset($tokens[$stackPtr]['scope_closer']) === false) {
140		return false;
141		}
142
143		$classOpenerIndex = $tokens[$stackPtr]['scope_opener'];
144		$implementsIndex = $phpcsFile->findNext(T_IMPLEMENTS, $stackPtr, $classOpenerIndex);
145		if ($implementsIndex === false) {
146		return false;
147		}
148
149		$find = array(
150		T_NS_SEPARATOR,
151		T_STRING,
152		T_WHITESPACE,
153		T_COMMA,
154		);
155
156		$end = $phpcsFile->findNext($find, ($implementsIndex + 1), ($classOpenerIndex + 1), true);
157		$name = $phpcsFile->getTokensAsString(($implementsIndex + 1), ($end - $implementsIndex - 1));
158		$name = trim($name);
159
160		if ($name === '') {
161		return false;
162		} else {
163		$names = explode(',', $name);
164		$names = array_map('trim', $names);
165		return $names;
166		}
167
168		}//end findImplementedInterfaceNames()
169
170
171		/**
172		* Checks if a function call has parameters.
173		*
174		* Expects to be passed the T_STRING stack pointer for the function call.
175		* If passed a T_STRING which is not a function call, the behaviour is unreliable.
176		*
177		* @link https://github.com/wimg/PHPCompatibility/issues/120
178		* @link https://github.com/wimg/PHPCompatibility/issues/152
179		*
180		* @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
181		* @param int $stackPtr The position of the function call token.
182		*
183		* @return bool
184		*/
185		public function doesFunctionCallHaveParameters(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
186		{
187		$tokens = $phpcsFile->getTokens();
188
189		// Check for the existence of the token.
190		if (isset($tokens[$stackPtr]) === false) {
191		return false;
192		}
193
194		if ($tokens[$stackPtr]['code'] !== T_STRING) {
195		return false;
196		}
197
198		// Next non-empty token should be the open parenthesis.
199		$openParenthesis = $phpcsFile->findNext(PHP_CodeSniffer_Tokens::$emptyTokens, $stackPtr + 1, null, true, null, true);
200		if ($openParenthesis === false \|\| $tokens[$openParenthesis]['code'] !== T_OPEN_PARENTHESIS) {
201		return false;
202		}
203
204		if (isset($tokens[$openParenthesis]['parenthesis_closer']) === false) {
205		return false;
206		}
207
208		$closeParenthesis = $tokens[$openParenthesis]['parenthesis_closer'];
209		$nextNonEmpty = $phpcsFile->findNext(PHP_CodeSniffer_Tokens::$emptyTokens, $openParenthesis + 1, $closeParenthesis + 1, true);
210
211		if ($nextNonEmpty === $closeParenthesis) {
212		// No parameters.
213		return false;
214		}
215
216		return true;
217		}
218
219
220		/**
221		* Count the number of parameters a function call has been passed.
222		*
223		* Expects to be passed the T_STRING stack pointer for the function call.
224		* If passed a T_STRING which is not a function call, the behaviour is unreliable.
225		*
226		* @link https://github.com/wimg/PHPCompatibility/issues/111
227		* @link https://github.com/wimg/PHPCompatibility/issues/114
228		* @link https://github.com/wimg/PHPCompatibility/issues/151
229		*
230		* @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
231		* @param int $stackPtr The position of the function call token.
232		*
233		* @return int
234		*/
235		public function getFunctionCallParameterCount(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
236		{
237		if ($this->doesFunctionCallHaveParameters($phpcsFile, $stackPtr) === false) {
238		return 0;
239		}
240
241		// Ok, we know we have a T_STRING with parameters and valid open & close parenthesis.
242		$tokens = $phpcsFile->getTokens();
243
244		$openParenthesis = $phpcsFile->findNext(PHP_CodeSniffer_Tokens::$emptyTokens, $stackPtr + 1, null, true, null, true);
245		$closeParenthesis = $tokens[$openParenthesis]['parenthesis_closer'];
246
247		// Which nesting level is the one we are interested in ?
248		$nestedParenthesisCount = 1;
249		if (isset($tokens[$openParenthesis]['nested_parenthesis'])) {
250		$nestedParenthesisCount = count($tokens[$openParenthesis]['nested_parenthesis']) + 1;
251		}
252
253		$nextComma = $openParenthesis;
254		$cnt = 0;
255		while ($nextComma = $phpcsFile->findNext(array(T_COMMA, T_CLOSE_PARENTHESIS), $nextComma + 1, $closeParenthesis + 1)) {
256		// Ignore comma's at a lower nesting level.
257		if (
258		$tokens[$nextComma]['type'] == 'T_COMMA'
259		&&
260		isset($tokens[$nextComma]['nested_parenthesis'])
261		&&
262		count($tokens[$nextComma]['nested_parenthesis']) != $nestedParenthesisCount
263		) {
264		continue;
265		}
266
267		// Ignore closing parenthesis if not 'ours'.
268		if ($tokens[$nextComma]['type'] == 'T_CLOSE_PARENTHESIS' && $nextComma != $closeParenthesis) {
269		continue;
270		}
271
272		$cnt++;
273		}
274
275		return $cnt;
276		}
277
278		}//end class
279

wimg / PHPCompatibility

Pull Request — master (#164)

PHPCompatibility_Sniff::supportsAbove() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like