NewLanguageConstructsSniff::getNonVersionArrayKeys() - Code Metrics - Inspection of "Refactor the error messages" - wimg/PHPCompatibility - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#291)

by Juliette

created 2016-10-30 16:06 UTC

getNonVersionArrayKeys() A

↳ Parent: NewLanguageConstructsSniff

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0

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

/**
 * PHPCompatibility_Sniffs_PHP_NewLanguageConstructsSniff.
 *
 * @category  PHP
 * @package   PHPCompatibility
 * @author    Wim Godden <[email protected]>
 * @version   1.0.0
 * @copyright 2013 Cu.be Solutions bvba
 */
class PHPCompatibility_Sniffs_PHP_NewLanguageConstructsSniff
namespace YourVendor;

class YourClass { }
    extends PHPCompatibility_AbstractNewFeatureSniff

{

    /**
     * A list of new language constructs, 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 keyword appears.
     *
     * @var array(string => array(string => int|string|null))
     */
    protected $newConstructs = array(
                                        'T_NS_SEPARATOR' => array(
                                            '5.2' => false,
                                            '5.3' => true,
                                            'description' => 'the \ operator (for namespaces)'
                                        ),
                                        'T_POW' => array(
                                            '5.5' => false,
                                            '5.6' => true,
                                            'description' => 'power operator (**)'
                                        ), // identified in PHPCS 1.5 as T_MULTIPLY + T_MULTIPLY
                                        'T_POW_EQUAL' => array(
                                            '5.5' => false,
                                            '5.6' => true,
                                            'description' => 'power assignment operator (**=)'
                                        ), // identified in PHPCS 1.5 as T_MULTIPLY + T_MUL_EQUAL
                                        'T_ELLIPSIS' => array(
                                            '5.5' => false,
                                            '5.6' => true,
                                            'description' => 'variadic functions using ...'
                                        ),
                                        'T_SPACESHIP' => array(
                                            '5.6' => false,
                                            '7.0' => true,
                                            'description' => 'spaceship operator (<=>)'
                                        ), // identified in PHPCS 1.5 as T_IS_SMALLER_OR_EQUAL + T_GREATER_THAN
                                        'T_COALESCE' => array(
                                            '5.6' => false,
                                            '7.0' => true,
                                            'description' => 'null coalescing operator (??)'
                                        ), // identified in PHPCS 1.5 as T_INLINE_THEN + T_INLINE_THEN
                                    );


    /**
     * A list of new language constructs which are not recognized in PHPCS 1.x.
     *
     * The array lists an alternative token to listen for.
     *
     * @var array(string => int)
     */
    protected $newConstructsPHPCSCompat = array(
                                        'T_POW'       => T_MULTIPLY,
                                        'T_POW_EQUAL' => T_MUL_EQUAL,
                                        'T_SPACESHIP' => T_GREATER_THAN,
                                        'T_COALESCE'  => T_INLINE_THEN,
                                    );

    /**
     * Translation table for PHPCS 1.x tokens.
     *
     * The 'before' index lists the token which would have to be directly before the
     * token found for it to be one of the new language constructs.
     * The 'real_token' index indicates which language construct was found in that case.
     *
     * {@internal 'before' was choosen rather than 'after' as that allowed for a 1-on-1
     * translation list with the current tokens.}}
     *
     * @var array(string => array(string => string))
     */
    protected $PHPCSCompatTranslate = array(
                                        'T_MULTIPLY' => array(
                                            'before' => 'T_MULTIPLY',
                                            'real_token' => 'T_POW',
                                        ),
                                        'T_MUL_EQUAL' => array(
                                            'before' => 'T_MULTIPLY',
                                            'real_token' => 'T_POW_EQUAL',
                                        ),
                                        'T_GREATER_THAN' => array(
                                            'before' => 'T_IS_SMALLER_OR_EQUAL',
                                            'real_token' => 'T_SPACESHIP',
                                        ),
                                        'T_INLINE_THEN' => array(
                                            'before' => 'T_INLINE_THEN',
                                            'real_token' => 'T_COALESCE',
                                        ),
                                    );

    /**
     * Returns an array of tokens this test wants to listen for.
     *
     * @return array
     */
    public function register()
    {
        $tokens = array();
        foreach ($this->newConstructs as $token => $versions) {
            if (defined($token)) {
                $tokens[] = constant($token);
            }
            else if(isset($this->newConstructsPHPCSCompat[$token])) {
                $tokens[] = $this->newConstructsPHPCSCompat[$token];
            }
        }
        return $tokens;
    }//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();
        $tokenType = $tokens[$stackPtr]['type'];

        // Translate pre-PHPCS 2.0 tokens for new constructs to the actual construct.
        if (isset($this->newConstructs[$tokenType]) === false) {
            if (
                isset($this->PHPCSCompatTranslate[$tokenType])
                &&
                $tokens[$stackPtr - 1]['type'] === $this->PHPCSCompatTranslate[$tokenType]['before']
            ) {
                $tokenType = $this->PHPCSCompatTranslate[$tokenType]['real_token'];
            }
        }

        // If the translation did not yield one of the tokens we are looking for, bow out.
        if (isset($this->newConstructs[$tokenType]) === false) {
            return;
        }

        $itemInfo = array(
            'name'   => $tokenType,
        );
        $this->handleFeature($phpcsFile, $stackPtr, $itemInfo);

    }//end process()


    /**
     * 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->newConstructs[$itemInfo['name']];
    }


    /**
     * Get an array of the non-PHP-version array keys used in a sub-array.
     *
     * @return array
     */
    protected function getNonVersionArrayKeys()
    {
        return array('description');
    }


    /**
     * Retrieve the relevant detail (version) information for use in an error message.
     *
     * @param array $itemArray Version and other information about the item.
     * @param array $itemInfo  Base information about the item.
     *
     * @return array
     */
    public function getErrorInfo(array $itemArray, array $itemInfo)
    {
        $errorInfo = parent::getErrorInfo($itemArray, $itemInfo);
        $errorInfo['description'] = $itemArray['description'];

        return $errorInfo;

    }


    /**
     * Allow for concrete child classes to filter the error data before it's passed to PHPCS.
     *
     * @param array $data      The error data array which was created.
     * @param array $itemInfo  Base information about the item this error message applied to.
     * @param array $errorInfo Detail information about an item this error message applied to.
     *
     * @return array
     */
    protected function filterErrorData(array $data, array $itemInfo, array $errorInfo)
    {
        $data[0] = $errorInfo['description'];
        return $data;
    }


}//end class


1			<?php
2			/**
3			* PHPCompatibility_Sniffs_PHP_NewLanguageConstructsSniff.
4			*
5			* PHP version 5.5
6			*
7			* @category PHP
8			* @package PHPCompatibility
9			* @author Wim Godden <[email protected]>
10			* @copyright 2013 Cu.be Solutions bvba
11			*/
12
13			/**
14			* PHPCompatibility_Sniffs_PHP_NewLanguageConstructsSniff.
15			*
16			* @category PHP
17			* @package PHPCompatibility
18			* @author Wim Godden <[email protected]>
19			* @version 1.0.0
20			* @copyright 2013 Cu.be Solutions bvba
21			*/
22			class PHPCompatibility_Sniffs_PHP_NewLanguageConstructsSniff
			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			extends PHPCompatibility_AbstractNewFeatureSniff
			0 ignored issues – show Coding Style introduced 2016-10-30 16:08 UTC by Report Bug Copy Issue Report The extends keyword must be on the same line as the class name Loading history...
24			{
25
26			/**
27			* A list of new language constructs, not present in older versions.
28			*
29			* The array lists : version number with false (not present) or true (present).
30			* If's sufficient to list the first version where the keyword appears.
31			*
32			* @var array(string => array(string => int\|string\|null))
33			*/
34			protected $newConstructs = array(
35			'T_NS_SEPARATOR' => array(
36			'5.2' => false,
37			'5.3' => true,
38			'description' => 'the \ operator (for namespaces)'
39			),
40			'T_POW' => array(
41			'5.5' => false,
42			'5.6' => true,
43			'description' => 'power operator (**)'
44			), // identified in PHPCS 1.5 as T_MULTIPLY + T_MULTIPLY
45			'T_POW_EQUAL' => array(
46			'5.5' => false,
47			'5.6' => true,
48			'description' => 'power assignment operator (**=)'
49			), // identified in PHPCS 1.5 as T_MULTIPLY + T_MUL_EQUAL
50			'T_ELLIPSIS' => array(
51			'5.5' => false,
52			'5.6' => true,
53			'description' => 'variadic functions using ...'
54			),
55			'T_SPACESHIP' => array(
56			'5.6' => false,
57			'7.0' => true,
58			'description' => 'spaceship operator (<=>)'
59			), // identified in PHPCS 1.5 as T_IS_SMALLER_OR_EQUAL + T_GREATER_THAN
60			'T_COALESCE' => array(
61			'5.6' => false,
62			'7.0' => true,
63			'description' => 'null coalescing operator (??)'
64			), // identified in PHPCS 1.5 as T_INLINE_THEN + T_INLINE_THEN
65			);
66
67
68			/**
69			* A list of new language constructs which are not recognized in PHPCS 1.x.
70			*
71			* The array lists an alternative token to listen for.
72			*
73			* @var array(string => int)
74			*/
75			protected $newConstructsPHPCSCompat = array(
76			'T_POW' => T_MULTIPLY,
77			'T_POW_EQUAL' => T_MUL_EQUAL,
78			'T_SPACESHIP' => T_GREATER_THAN,
79			'T_COALESCE' => T_INLINE_THEN,
80			);
81
82			/**
83			* Translation table for PHPCS 1.x tokens.
84			*
85			* The 'before' index lists the token which would have to be directly before the
86			* token found for it to be one of the new language constructs.
87			* The 'real_token' index indicates which language construct was found in that case.
88			*
89			* {@internal 'before' was choosen rather than 'after' as that allowed for a 1-on-1
90			* translation list with the current tokens.}}
91			*
92			* @var array(string => array(string => string))
93			*/
94			protected $PHPCSCompatTranslate = array(
95			'T_MULTIPLY' => array(
96			'before' => 'T_MULTIPLY',
97			'real_token' => 'T_POW',
98			),
99			'T_MUL_EQUAL' => array(
100			'before' => 'T_MULTIPLY',
101			'real_token' => 'T_POW_EQUAL',
102			),
103			'T_GREATER_THAN' => array(
104			'before' => 'T_IS_SMALLER_OR_EQUAL',
105			'real_token' => 'T_SPACESHIP',
106			),
107			'T_INLINE_THEN' => array(
108			'before' => 'T_INLINE_THEN',
109			'real_token' => 'T_COALESCE',
110			),
111			);
112
113			/**
114			* Returns an array of tokens this test wants to listen for.
115			*
116			* @return array
117			*/
118			public function register()
119			{
120			$tokens = array();
121			foreach ($this->newConstructs as $token => $versions) {
122			if (defined($token)) {
123			$tokens[] = constant($token);
124			}
125			else if(isset($this->newConstructsPHPCSCompat[$token])) {
126			$tokens[] = $this->newConstructsPHPCSCompat[$token];
127			}
128			}
129			return $tokens;
130			}//end register()
131
132
133			/**
134			* Processes this test, when one of its tokens is encountered.
135			*
136			* @param PHP_CodeSniffer_File $phpcsFile The file being scanned.
137			* @param int $stackPtr The position of the current token in
138			* the stack passed in $tokens.
139			*
140			* @return void
141			*/
142			public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
143			{
144			$tokens = $phpcsFile->getTokens();
145			$tokenType = $tokens[$stackPtr]['type'];
146
147			// Translate pre-PHPCS 2.0 tokens for new constructs to the actual construct.
148			if (isset($this->newConstructs[$tokenType]) === false) {
149			if (
150			isset($this->PHPCSCompatTranslate[$tokenType])
151			&&
152			$tokens[$stackPtr - 1]['type'] === $this->PHPCSCompatTranslate[$tokenType]['before']
153			) {
154			$tokenType = $this->PHPCSCompatTranslate[$tokenType]['real_token'];
155			}
156			}
157
158			// If the translation did not yield one of the tokens we are looking for, bow out.
159			if (isset($this->newConstructs[$tokenType]) === false) {
160			return;
161			}
162
163			$itemInfo = array(
164			'name' => $tokenType,
165			);
166			$this->handleFeature($phpcsFile, $stackPtr, $itemInfo);
167
168			}//end process()
169
170
171			/**
172			* Get the relevant sub-array for a specific item from a multi-dimensional array.
173			*
174			* @param array $itemInfo Base information about the item.
175			*
176			* @return array Version and other information about the item.
177			*/
178			public function getItemArray(array $itemInfo)
179			{
180			return $this->newConstructs[$itemInfo['name']];
181			}
182
183
184			/**
185			* Get an array of the non-PHP-version array keys used in a sub-array.
186			*
187			* @return array
188			*/
189			protected function getNonVersionArrayKeys()
190			{
191			return array('description');
192			}
193
194
195			/**
196			* Retrieve the relevant detail (version) information for use in an error message.
197			*
198			* @param array $itemArray Version and other information about the item.
199			* @param array $itemInfo Base information about the item.
200			*
201			* @return array
202			*/
203			public function getErrorInfo(array $itemArray, array $itemInfo)
204			{
205			$errorInfo = parent::getErrorInfo($itemArray, $itemInfo);
206			$errorInfo['description'] = $itemArray['description'];
207
208			return $errorInfo;
209
210			}
211
212
213			/**
214			* Allow for concrete child classes to filter the error data before it's passed to PHPCS.
215			*
216			* @param array $data The error data array which was created.
217			* @param array $itemInfo Base information about the item this error message applied to.
218			* @param array $errorInfo Detail information about an item this error message applied to.
219			*
220			* @return array
221			*/
222			protected function filterErrorData(array $data, array $itemInfo, array $errorInfo)
223			{
224			$data[0] = $errorInfo['description'];
225			return $data;
226			}
227
228
229			}//end class
230

wimg / PHPCompatibility

Pull Request — master (#291)

getNonVersionArrayKeys() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like