1897

pending completion

Build # 1897

Build Type

Pull #702

travis-ci

Committed by

web-flow

Commit Message

PHP 7.3: NewIniDirectives: account for new ini directives

Refs:
* https://github.com/php/php-src/blob/3b6e1ee4e/UPGRADING#L459-L465
* https://github.com/php/php-src/commit/2475337bd

Pull Request Pull Request #702: PHP 7.3: NewIniDirectives: account for new ini directives

Run Details

3143 of 3302 relevant lines covered (95.18%)

30.21 hits per line

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

96.88

/PHPCompatibility/Sniffs/PHP/NewInterfacesSniff.php

<?php
/**
 * \PHPCompatibility\Sniffs\PHP\NewInterfacesSniff.
 *
 * @category PHP
 * @package  PHPCompatibility
 * @author   Juliette Reinders Folmer <phpcompatibility_nospam@adviesenzo.nl>
 */

namespace PHPCompatibility\Sniffs\PHP;

use PHPCompatibility\AbstractNewFeatureSniff;
use PHPCompatibility\PHPCSHelper;

/**
 * \PHPCompatibility\Sniffs\PHP\NewInterfacesSniff.
 *
 * @category PHP
 * @package  PHPCompatibility
 * @author   Juliette Reinders Folmer <phpcompatibility_nospam@adviesenzo.nl>
 */
class NewInterfacesSniff extends AbstractNewFeatureSniff
{

    /**
     * A list of new interfaces, not present in older versions.
     *
     * The array lists : version number with false (not present) or true (present).
     * If's sufficient to list the first version where the interface appears.
     *
     * @var array(string => array(string => int|string|null))
     */
    protected $newInterfaces = array(
        'Traversable' => array(
            '4.4' => false,
            '5.0' => true,
        ),
        'Reflector' => array(
            '4.4' => false,
            '5.0' => true,
        ),

        'Countable' => array(
            '5.0' => false,
            '5.1' => true,
        ),
        'OuterIterator' => array(
            '5.0' => false,
            '5.1' => true,
        ),
        'RecursiveIterator' => array(
            '5.0' => false,
            '5.1' => true,
        ),
        'SeekableIterator' => array(
            '5.0' => false,
            '5.1' => true,
        ),
        'Serializable' => array(
            '5.0' => false,
            '5.1' => true,
        ),
        'SplObserver' => array(
            '5.0' => false,
            '5.1' => true,
        ),
        'SplSubject' => array(
            '5.0' => false,
            '5.1' => true,
        ),

        'JsonSerializable' => array(
            '5.3' => false,
            '5.4' => true,
        ),
        'SessionHandlerInterface' => array(
            '5.3' => false,
            '5.4' => true,
        ),

        'DateTimeInterface' => array(
            '5.4' => false,
            '5.5' => true,
        ),

        'Throwable' => array(
            '5.6' => false,
            '7.0' => true,
        ),

    );

    /**
     * A list of methods which cannot be used in combination with particular interfaces.
     *
     * @var array(string => array(string => string))
     */
    protected $unsupportedMethods = array(
        'Serializable' => array(
            '__sleep'  => 'http://php.net/serializable',
            '__wakeup' => 'http://php.net/serializable',
        ),
    );

    /**
     * Returns an array of tokens this test wants to listen for.
     *
     * @return array
     */
    public function register()
    {
        // Handle case-insensitivity of interface names.
        $this->newInterfaces      = $this->arrayKeysToLowercase($this->newInterfaces);
        $this->unsupportedMethods = $this->arrayKeysToLowercase($this->unsupportedMethods);

        $targets = array(
            T_CLASS,
            T_FUNCTION,
            T_CLOSURE,
        );

        if (defined('T_ANON_CLASS')) {
            // phpcs:ignore PHPCompatibility.PHP.NewConstants.t_anon_classFound
            $targets[] = T_ANON_CLASS;
        }

        if (defined('T_RETURN_TYPE')) {
            $targets[] = T_RETURN_TYPE;
        }

        return $targets;

    }//end register()


    /**
     * 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)
    {
        $tokens = $phpcsFile->getTokens();

        switch ($tokens[$stackPtr]['type']) {
            case 'T_CLASS':
            case 'T_ANON_CLASS':
                $this->processClassToken($phpcsFile, $stackPtr);
                break;

            case 'T_FUNCTION':
            case 'T_CLOSURE':
                $this->processFunctionToken($phpcsFile, $stackPtr);

                // Deal with older PHPCS versions which don't recognize return type hints
                // as well as newer PHPCS versions (3.3.0+) where the tokenization has changed.
                $returnTypeHint = $this->getReturnTypeHintToken($phpcsFile, $stackPtr);
                if ($returnTypeHint !== false) {
                    $this->processReturnTypeToken($phpcsFile, $returnTypeHint);
                }
                break;

            case 'T_RETURN_TYPE':
                $this->processReturnTypeToken($phpcsFile, $stackPtr);
                break;

            default:
                // Deliberately left empty.
                break;
        }

    }//end process()


    /**
     * Processes this test for when a class token is encountered.
     *
     * - Detect classes implementing the new interfaces.
     * - Detect classes implementing the new interfaces with unsupported functions.
     *
     * @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
     */
    private function processClassToken(\PHP_CodeSniffer_File $phpcsFile, $stackPtr)
    {
        $interfaces = PHPCSHelper::findImplementedInterfaceNames($phpcsFile, $stackPtr);

        if (is_array($interfaces) === false || $interfaces === array()) {
            return;
        }

        $tokens       = $phpcsFile->getTokens();
        $checkMethods = false;

        if (isset($tokens[$stackPtr]['scope_closer'])) {
            $checkMethods = true;
            $scopeCloser  = $tokens[$stackPtr]['scope_closer'];
        }

        foreach ($interfaces as $interface) {
            $interfaceLc = strtolower($interface);

            if (isset($this->newInterfaces[$interfaceLc]) === true) {
                $itemInfo = array(
                    'name'   => $interface,
                    'nameLc' => $interfaceLc,
                );
                $this->handleFeature($phpcsFile, $stackPtr, $itemInfo);
            }

            if ($checkMethods === true && isset($this->unsupportedMethods[$interfaceLc]) === true) {
                $nextFunc = $stackPtr;
                while (($nextFunc = $phpcsFile->findNext(T_FUNCTION, ($nextFunc + 1), $scopeCloser)) !== false) {
                    $funcName   = $phpcsFile->getDeclarationName($nextFunc);
                    $funcNameLc = strtolower($funcName);
                    if ($funcNameLc === '') {
                        continue;
                    }

                    if (isset($this->unsupportedMethods[$interfaceLc][$funcNameLc]) === true) {
                        $error     = 'Classes that implement interface %s do not support the method %s(). See %s';
                        $errorCode = $this->stringToErrorCode($interface) . 'UnsupportedMethod';
                        $data      = array(
                            $interface,
                            $funcName,
                            $this->unsupportedMethods[$interfaceLc][$funcNameLc],
                        );

                        $phpcsFile->addError($error, $nextFunc, $errorCode, $data);
                    }
                }
            }
        }
    }//end processClassToken()


    /**
     * Processes this test for when a function token is encountered.
     *
     * - Detect new interfaces when used as a type hint.
     *
     * @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
     */
    private function processFunctionToken(\PHP_CodeSniffer_File $phpcsFile, $stackPtr)
    {
        $typeHints = $this->getTypeHintsFromFunctionDeclaration($phpcsFile, $stackPtr);
        if (empty($typeHints) || is_array($typeHints) === false) {
            return;
        }

        foreach ($typeHints as $hint) {

            $typeHintLc = strtolower($hint);

            if (isset($this->newInterfaces[$typeHintLc]) === true) {
                $itemInfo = array(
                    'name'   => $hint,
                    'nameLc' => $typeHintLc,
                );
                $this->handleFeature($phpcsFile, $stackPtr, $itemInfo);
            }
        }
    }


    /**
     * Processes this test for when a return type token is encountered.
     *
     * - Detect new interfaces when used as a return type declaration.
     *
     * @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
     */
    private function processReturnTypeToken(\PHP_CodeSniffer_File $phpcsFile, $stackPtr)
    {
        $returnTypeHint   = $this->getReturnTypeHintName($phpcsFile, $stackPtr);
        $returnTypeHint   = ltrim($returnTypeHint, '\\');
        $returnTypeHintLc = strtolower($returnTypeHint);

        if (isset($this->newInterfaces[$returnTypeHintLc]) === false) {
            return;
        }

        // Still here ? Then this is a return type declaration using a new interface.
        $itemInfo = array(
            'name'   => $returnTypeHint,
            'nameLc' => $returnTypeHintLc,
        );
        $this->handleFeature($phpcsFile, $stackPtr, $itemInfo);
    }


    /**
     * Get the relevant sub-array for a specific item from a multi-dimensional array.
     *
     * @param array $itemInfo Base information about the item.
     *
     * @return array Version and other information about the item.
     */
    public function getItemArray(array $itemInfo)
    {
        return $this->newInterfaces[$itemInfo['nameLc']];
    }


    /**
     * Get the error message template for this sniff.
     *
     * @return string
     */
    protected function getErrorMsgTemplate()
    {
        return 'The built-in interface ' . parent::getErrorMsgTemplate();
    }


}//end class

1	<?php
2	/**
3	* \PHPCompatibility\Sniffs\PHP\NewInterfacesSniff.
4	*
5	* @category PHP
6	* @package PHPCompatibility
7	* @author Juliette Reinders Folmer <phpcompatibility_nospam@adviesenzo.nl>
8	*/
9
10	namespace PHPCompatibility\Sniffs\PHP;
11
12	use PHPCompatibility\AbstractNewFeatureSniff;
13	use PHPCompatibility\PHPCSHelper;
14
15	/**
16	* \PHPCompatibility\Sniffs\PHP\NewInterfacesSniff.
17	*
18	* @category PHP
19	* @package PHPCompatibility
20	* @author Juliette Reinders Folmer <phpcompatibility_nospam@adviesenzo.nl>
21	*/
22	class NewInterfacesSniff extends AbstractNewFeatureSniff
23	{
24
25	/**
26	* A list of new interfaces, not present in older versions.
27	*
28	* The array lists : version number with false (not present) or true (present).
29	* If's sufficient to list the first version where the interface appears.
30	*
31	* @var array(string => array(string => int\|string\|null))
32	*/
33	protected $newInterfaces = array(
34	'Traversable' => array(
35	'4.4' => false,
36	'5.0' => true,
37	),
38	'Reflector' => array(
39	'4.4' => false,
40	'5.0' => true,
41	),
42
43	'Countable' => array(
44	'5.0' => false,
45	'5.1' => true,
46	),
47	'OuterIterator' => array(
48	'5.0' => false,
49	'5.1' => true,
50	),
51	'RecursiveIterator' => array(
52	'5.0' => false,
53	'5.1' => true,
54	),
55	'SeekableIterator' => array(
56	'5.0' => false,
57	'5.1' => true,
58	),
59	'Serializable' => array(
60	'5.0' => false,
61	'5.1' => true,
62	),
63	'SplObserver' => array(
64	'5.0' => false,
65	'5.1' => true,
66	),
67	'SplSubject' => array(
68	'5.0' => false,
69	'5.1' => true,
70	),
71
72	'JsonSerializable' => array(
73	'5.3' => false,
74	'5.4' => true,
75	),
76	'SessionHandlerInterface' => array(
77	'5.3' => false,
78	'5.4' => true,
79	),
80
81	'DateTimeInterface' => array(
82	'5.4' => false,
83	'5.5' => true,
84	),
85
86	'Throwable' => array(
87	'5.6' => false,
88	'7.0' => true,
89	),
90
91	);
92
93	/**
94	* A list of methods which cannot be used in combination with particular interfaces.
95	*
96	* @var array(string => array(string => string))
97	*/
98	protected $unsupportedMethods = array(
99	'Serializable' => array(
100	'__sleep' => 'http://php.net/serializable',
101	'__wakeup' => 'http://php.net/serializable',
102	),
103	);
104
105	/**
106	* Returns an array of tokens this test wants to listen for.
107	*
108	* @return array
109	*/
110	public function register()
111	{
112	// Handle case-insensitivity of interface names.
113	$this->newInterfaces = $this->arrayKeysToLowercase($this->newInterfaces);	114✔
114	$this->unsupportedMethods = $this->arrayKeysToLowercase($this->unsupportedMethods);	114✔
115
116	$targets = array(
117	T_CLASS,	114✔
118	T_FUNCTION,	114✔
119	T_CLOSURE,	114✔
120	);	57✔
121
122	if (defined('T_ANON_CLASS')) {	114✔
123	// phpcs:ignore PHPCompatibility.PHP.NewConstants.t_anon_classFound
124	$targets[] = T_ANON_CLASS;	36✔
125	}	31✔
126
127	if (defined('T_RETURN_TYPE')) {	114✔
128	$targets[] = T_RETURN_TYPE;	36✔
129	}	31✔
130
131	return $targets;	114✔
132
133	}//end register()
134
135
136	/**
137	* Processes this test, when one of its tokens is encountered.
138	*
139	* @param \PHP_CodeSniffer_File $phpcsFile The file being scanned.
140	* @param int $stackPtr The position of the current token in
141	* the stack passed in $tokens.
142	*
143	* @return void
144	*/
145	public function process(\PHP_CodeSniffer_File $phpcsFile, $stackPtr)
146	{
147	$tokens = $phpcsFile->getTokens();	30✔
148
149	switch ($tokens[$stackPtr]['type']) {	30✔
150	case 'T_CLASS':	30✔
151	case 'T_ANON_CLASS':	30✔
152	$this->processClassToken($phpcsFile, $stackPtr);	30✔
153	break;	30✔
154
155	case 'T_FUNCTION':	30✔
156	case 'T_CLOSURE':	30✔
157	$this->processFunctionToken($phpcsFile, $stackPtr);	30✔
158
159	// Deal with older PHPCS versions which don't recognize return type hints
160	// as well as newer PHPCS versions (3.3.0+) where the tokenization has changed.
161	$returnTypeHint = $this->getReturnTypeHintToken($phpcsFile, $stackPtr);	30✔
162	if ($returnTypeHint !== false) {	30✔
163	$this->processReturnTypeToken($phpcsFile, $returnTypeHint);	30✔
164	}	15✔
165	break;	30✔
166
167	case 'T_RETURN_TYPE':	5✔
168	$this->processReturnTypeToken($phpcsFile, $stackPtr);	5✔
169	break;	5✔
170
171	default:
172	// Deliberately left empty.
173	break;	×
174	}	15✔
175
176	}//end process()	30✔
177
178
179	/**
180	* Processes this test for when a class token is encountered.
181	*
182	* - Detect classes implementing the new interfaces.
183	* - Detect classes implementing the new interfaces with unsupported functions.
184	*
185	* @param \PHP_CodeSniffer_File $phpcsFile The file being scanned.
186	* @param int $stackPtr The position of the current token in
187	* the stack passed in $tokens.
188	*
189	* @return void
190	*/
191	private function processClassToken(\PHP_CodeSniffer_File $phpcsFile, $stackPtr)
192	{
193	$interfaces = PHPCSHelper::findImplementedInterfaceNames($phpcsFile, $stackPtr);	30✔
194
195	if (is_array($interfaces) === false \|\| $interfaces === array()) {	30✔
196	return;	30✔
197	}
198
199	$tokens = $phpcsFile->getTokens();	30✔
200	$checkMethods = false;	30✔
201
202	if (isset($tokens[$stackPtr]['scope_closer'])) {	30✔
203	$checkMethods = true;	30✔
204	$scopeCloser = $tokens[$stackPtr]['scope_closer'];	30✔
205	}	15✔
206
207	foreach ($interfaces as $interface) {	30✔
208	$interfaceLc = strtolower($interface);	30✔
209
210	if (isset($this->newInterfaces[$interfaceLc]) === true) {	30✔
211	$itemInfo = array(
212	'name' => $interface,	30✔
213	'nameLc' => $interfaceLc,	30✔
214	);	15✔
215	$this->handleFeature($phpcsFile, $stackPtr, $itemInfo);	30✔
216	}	15✔
217
218	if ($checkMethods === true && isset($this->unsupportedMethods[$interfaceLc]) === true) {	30✔
219	$nextFunc = $stackPtr;	30✔
220	while (($nextFunc = $phpcsFile->findNext(T_FUNCTION, ($nextFunc + 1), $scopeCloser)) !== false) {	30✔
221	$funcName = $phpcsFile->getDeclarationName($nextFunc);	30✔
222	$funcNameLc = strtolower($funcName);	30✔
223	if ($funcNameLc === '') {	30✔
224	continue;	×
225	}
226
227	if (isset($this->unsupportedMethods[$interfaceLc][$funcNameLc]) === true) {	30✔
228	$error = 'Classes that implement interface %s do not support the method %s(). See %s';	30✔
229	$errorCode = $this->stringToErrorCode($interface) . 'UnsupportedMethod';	30✔
230	$data = array(
231	$interface,	30✔
232	$funcName,	30✔
233	$this->unsupportedMethods[$interfaceLc][$funcNameLc],	30✔
234	);	15✔
235
236	$phpcsFile->addError($error, $nextFunc, $errorCode, $data);	30✔
237	}	15✔
238	}	15✔
239	}	15✔
240	}	15✔
241	}//end processClassToken()	30✔
242
243
244	/**
245	* Processes this test for when a function token is encountered.
246	*
247	* - Detect new interfaces when used as a type hint.
248	*
249	* @param \PHP_CodeSniffer_File $phpcsFile The file being scanned.
250	* @param int $stackPtr The position of the current token in
251	* the stack passed in $tokens.
252	*
253	* @return void
254	*/
255	private function processFunctionToken(\PHP_CodeSniffer_File $phpcsFile, $stackPtr)
256	{
257	$typeHints = $this->getTypeHintsFromFunctionDeclaration($phpcsFile, $stackPtr);	30✔
258	if (empty($typeHints) \|\| is_array($typeHints) === false) {	30✔
259	return;	30✔
260	}
261
262	foreach ($typeHints as $hint) {	30✔
263
264	$typeHintLc = strtolower($hint);	30✔
265
266	if (isset($this->newInterfaces[$typeHintLc]) === true) {	30✔
267	$itemInfo = array(
268	'name' => $hint,	30✔
269	'nameLc' => $typeHintLc,	30✔
270	);	15✔
271	$this->handleFeature($phpcsFile, $stackPtr, $itemInfo);	30✔
272	}	15✔
273	}	15✔
274	}	30✔
275
276
277	/**
278	* Processes this test for when a return type token is encountered.
279	*
280	* - Detect new interfaces when used as a return type declaration.
281	*
282	* @param \PHP_CodeSniffer_File $phpcsFile The file being scanned.
283	* @param int $stackPtr The position of the current token in
284	* the stack passed in $tokens.
285	*
286	* @return void
287	*/
288	private function processReturnTypeToken(\PHP_CodeSniffer_File $phpcsFile, $stackPtr)
289	{
290	$returnTypeHint = $this->getReturnTypeHintName($phpcsFile, $stackPtr);	30✔
291	$returnTypeHint = ltrim($returnTypeHint, '\\');	30✔
292	$returnTypeHintLc = strtolower($returnTypeHint);	30✔
293
294	if (isset($this->newInterfaces[$returnTypeHintLc]) === false) {	30✔
295	return;	30✔
296	}
297
298	// Still here ? Then this is a return type declaration using a new interface.
299	$itemInfo = array(
300	'name' => $returnTypeHint,	30✔
301	'nameLc' => $returnTypeHintLc,	30✔
302	);	15✔
303	$this->handleFeature($phpcsFile, $stackPtr, $itemInfo);	30✔
304	}	30✔
305
306
307	/**
308	* Get the relevant sub-array for a specific item from a multi-dimensional array.
309	*
310	* @param array $itemInfo Base information about the item.
311	*
312	* @return array Version and other information about the item.
313	*/
314	public function getItemArray(array $itemInfo)
315	{
316	return $this->newInterfaces[$itemInfo['nameLc']];	30✔
317	}
318
319
320	/**
321	* Get the error message template for this sniff.
322	*
323	* @return string
324	*/
325	protected function getErrorMsgTemplate()
326	{
327	return 'The built-in interface ' . parent::getErrorMsgTemplate();	30✔
328	}
329
330
331	}//end class

PHPCompatibility / PHPCompatibility / 1897

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