File::addWarning() - Code Metrics - Inspection of "Feature/phpcs 28 typehint arrays" - bestit/PHP_CodeSniffer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#20)

unknown

created 2017-08-23 12:52 UTC

File::addWarning() A

↳ Parent: File

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	8
ccs	2
cts	2
cp	1
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	7
nc	1
nop	4
crap	1

<?php

declare(strict_types=1);

namespace BestIt\CodeSniffer;

use PHP_CodeSniffer_File;

/**
 * Class File
 *
 * Wrapper Class for PHP_CodeSniffer_File to provide a consistent way to replace int|bool returns
 * with int returns (false => -1)
 * Additionally there could be some architecture changes in the future, like Token-Objects and so on.
 *
 * @package BestIt\CodeSniffer
 * @author Nick Lubisch <[email protected]>
 */
class File
{
    /**
     * The CodeSniffer file
     *
     * @var PHP_CodeSniffer_File
     */
    private $baseFile;

    /**
     * Wrapped PHP_CodeSniffer_Fixer
     *
     * @var Fixer
     */
    private $fixer;

    /**
     * Contains the advanced token stack
     *
     * @var array
     */
    private $tokens;

    /**
     * File constructor.
     *
     * @param PHP_CodeSniffer_File $baseFile CodeSniffer file
     */
    public function __construct(PHP_CodeSniffer_File $baseFile)
    {
        $this->baseFile = $baseFile;
        $this->fixer = new Fixer($this, $this->baseFile->fixer);
        $this->tokens = $this->getAdvancedTokens();
    }

    /**
     * Adds the pointer to all token data arrays.
     *
     * @return array Advanced token stack.
     */
    private function getAdvancedTokens(): array
    {
        $tokens = [];

        foreach ($this->baseFile->getTokens() as $tokenPtr => $token) {
            $token['pointer'] = $tokenPtr;
            $tokens[$tokenPtr] = $token;
        }

        return $tokens;
    }

    /**
     * Records a fixable error against a specific token in the file.
     *
     * @param string $error The error message.
     * @param int $stackPtr The stack position where the error occurred.
     * @param string $code A violation code unique to the sniff message.
     * @param array $data Replacements for the error message.
     * @param int $severity The severity level for this error.
     *                      A value of 0 will be converted into the default severity level.
     *
     * @return bool Returns true if the error was recorded and should be fixed.
     */
    public function addFixableError(
        string $error,
        int $stackPtr,
        string $code = '',
        array $data = [],
        int $severity = 0
    ): bool {
         return $this->baseFile->addFixableError($error, $stackPtr, $code, $data, $severity);
    }

    /**
     * Returns the token stack for this file.
     *
     * @return array Return array of token data
     */
    public function getTokens(): array
    {
        return $this->tokens;
    }

    /**
     * Returns the position of the previous specified token(s).
     *
     * If a value is specified, the previous token of the specified type(s)
     * containing the specified value will be returned.
     *
     * Returns -1 if no token can be found.
     *
     * @param array $types The type(s) of tokens to search for.
     * @param int $start The position to start searching from in the token stack.
     * @param int $end The end position to fail if no token is found.
     *        if not specified or null, end will default to the start of the token stack.
     * @param bool $exclude If true, find the previous token that are NOT of the types specified in $types.
     * @param string $value The value that the token(s) must be equal to.
     *        If value is omitted, tokens with any value will be returned.
     * @param bool $local If true, tokens outside the current statement will not be checked.
     *        IE. checking will stop at the previous semi-colon found.
     *
     * @return int Pointer to the found token
     *
     * @SuppressWarnings(PHPMD.BooleanArgumentFlag)
     */
    public function findPrevious(
        array $types,
        int $start,
        ?int $end = null,
        bool $exclude = false,
        ?string $value = null,
        bool $local = false
    ): int {
        $pointer = $this->baseFile->findPrevious($types, $start, $end, $exclude, $value, $local);

        return $this->preparePointer($pointer);
    }

    /**
     * Records an error against a specific token in the file.
     *
     * @param string $error The error message.
     * @param int $stackPtr The stack position where the error occurred.
     * @param string $code A violation code unique to the sniff message.
     * @param array $data Replacements for the error message.
     * @param int $severity The severity level for this error. A value of 0
     *                      will be converted into the default severity level.
     * @param bool $fixable Can the error be fixed by the sniff?
     *
     * @return bool Returns true if setting the error was done or false
     *
     * @SuppressWarnings(PHPMD.BooleanArgumentFlag)
     */
    public function addError(
        string $error,
        int $stackPtr,
        string $code = '',
        array $data = [],
        int $severity = 0,
        bool $fixable = false
    ): bool {
        return $this->baseFile->addError($error, $stackPtr, $code, $data, $severity, $fixable);
    }

    /**
     * Records an error against a specific line in the file.
     *
     * @param string $error The error message.
     * @param int $line The line on which the error occurred.
     * @param string $code A violation code unique to the sniff message.
     * @param array $data Replacements for the error message.
     * @param int $severity The severity level for this error. A value of 0
     *                      will be converted into the default severity level.
     *
     * @return bool Returns true of the error got recorded
     */
    public function addErrorOnLine(
        string $error,
        int $line,
        string $code = '',
        array $data = [],
        int $severity = 0
    ): bool {
        return $this->baseFile->addErrorOnLine($error, $line, $code, $data, $severity);
    }

    /**
     * Records a warning on the given line of the file
     *
     * @param string $warning The warning message
     * @param int $stackPointer The stack position where the warning occured
     * @param string $code The warning code
     * @param array $data Replacements for the warning message
     *
     * @return bool Returns if a warning was added
     */
    public function addWarning(
        string $warning,
        int $stackPointer,
        string $code = '',
        array $data = []
    ): bool {
        return $this->baseFile->addWarning($warning, $stackPointer, $code, $data);
    }

    /**
     * Returns the position of the next specified token(s).
     *
     * If a value is specified, the next token of the specified type(s)
     * containing the specified value will be returned.
     *
     * Returns false if no token can be found.
     *
     * @param array $types The type(s) of tokens to search for.
     * @param int $start The position to start searching from in the
     *                   token stack.
     * @param int $end The end position to fail if no token is found. if not specified or null, end will default to
     *                 the end of the token stack.
     * @param bool $exclude If true, find the next token that is NOT of a type specified in $types.
     * @param string $value The value that the token(s) must be equal to.
     *                      If value is omitted, tokens with any value will be returned.
     * @param bool $local If true, tokens outside the current statement will not be checked. i.e., checking will stop
     *                    at the next semi-colon found.
     *
     * @return int Returns the pointer of the token or -1
     *
     * @SuppressWarnings(PHPMD.BooleanArgumentFlag)
     */
    public function findNext(
        array $types,
        int $start,
        ?int $end = null,
        bool $exclude = false,
        ?string $value = null,
        bool $local = false
    ): int {
        $result = $this->baseFile->findNext($types, $start, $end, $exclude, $value, $local);

        return $this->preparePointer($result);
    }

    /**
     * Prepares given pointer result.
     *
     * @param int|bool $pointer Pointer of a token
     *
     * @return int Pointer or -1 when not found
     */
    public function preparePointer($pointer): int
    {
        return $pointer !== false ? $pointer : -1;
    }

    /**
     * Returns the Wrapped PHP_CodeSniffer_Fixer
     *
     * @return Fixer Returns the wrapped PHP_CodeSniffer_Fixer
     */
    public function getFixer(): Fixer
    {
        return $this->fixer;
    }

    /**
     * Returns the eol char of the file
     *
     * @return string Returns the EndOfLine-Character of the processed file
     */
    public function getEolChar(): string
    {
        return $this->baseFile->eolChar;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace BestIt\CodeSniffer;
6
7		use PHP_CodeSniffer_File;
8
9		/**
10		* Class File
11		*
12		* Wrapper Class for PHP_CodeSniffer_File to provide a consistent way to replace int\|bool returns
13		* with int returns (false => -1)
14		* Additionally there could be some architecture changes in the future, like Token-Objects and so on.
15		*
16		* @package BestIt\CodeSniffer
17		* @author Nick Lubisch <[email protected]>
18		*/
19		class File
20		{
21		/**
22		* The CodeSniffer file
23		*
24		* @var PHP_CodeSniffer_File
25		*/
26		private $baseFile;
27
28		/**
29		* Wrapped PHP_CodeSniffer_Fixer
30		*
31		* @var Fixer
32		*/
33		private $fixer;
34
35		/**
36		* Contains the advanced token stack
37		*
38		* @var array
39		*/
40		private $tokens;
41
42		/**
43		* File constructor.
44		*
45		* @param PHP_CodeSniffer_File $baseFile CodeSniffer file
46		*/
47	103	public function __construct(PHP_CodeSniffer_File $baseFile)
48		{
49	103	$this->baseFile = $baseFile;
50	103	$this->fixer = new Fixer($this, $this->baseFile->fixer);
51	103	$this->tokens = $this->getAdvancedTokens();
52	103	}
53
54		/**
55		* Adds the pointer to all token data arrays.
56		*
57		* @return array Advanced token stack.
58		*/
59	103	private function getAdvancedTokens(): array
60		{
61	103	$tokens = [];
62
63	103	foreach ($this->baseFile->getTokens() as $tokenPtr => $token) {
64	103	$token['pointer'] = $tokenPtr;
65	103	$tokens[$tokenPtr] = $token;
66		}
67
68	103	return $tokens;
69		}
70
71		/**
72		* Records a fixable error against a specific token in the file.
73		*
74		* @param string $error The error message.
75		* @param int $stackPtr The stack position where the error occurred.
76		* @param string $code A violation code unique to the sniff message.
77		* @param array $data Replacements for the error message.
78		* @param int $severity The severity level for this error.
79		* A value of 0 will be converted into the default severity level.
80		*
81		* @return bool Returns true if the error was recorded and should be fixed.
82		*/
83	59	public function addFixableError(
84		string $error,
85		int $stackPtr,
86		string $code = '',
87		array $data = [],
88		int $severity = 0
89		): bool {
90	59	return $this->baseFile->addFixableError($error, $stackPtr, $code, $data, $severity);
91		}
92
93		/**
94		* Returns the token stack for this file.
95		*
96		* @return array Return array of token data
97		*/
98	103	public function getTokens(): array
99		{
100	103	return $this->tokens;
101		}
102
103		/**
104		* Returns the position of the previous specified token(s).
105		*
106		* If a value is specified, the previous token of the specified type(s)
107		* containing the specified value will be returned.
108		*
109		* Returns -1 if no token can be found.
110		*
111		* @param array $types The type(s) of tokens to search for.
112		* @param int $start The position to start searching from in the token stack.
113		* @param int $end The end position to fail if no token is found.
114		* if not specified or null, end will default to the start of the token stack.
115		* @param bool $exclude If true, find the previous token that are NOT of the types specified in $types.
116		* @param string $value The value that the token(s) must be equal to.
117		* If value is omitted, tokens with any value will be returned.
118		* @param bool $local If true, tokens outside the current statement will not be checked.
119		* IE. checking will stop at the previous semi-colon found.
120		*
121		* @return int Pointer to the found token
122		*
123		* @SuppressWarnings(PHPMD.BooleanArgumentFlag)
124		*/
125	103	public function findPrevious(
126		array $types,
127		int $start,
128		?int $end = null,
129		bool $exclude = false,
130		?string $value = null,
131		bool $local = false
132		): int {
133	103	$pointer = $this->baseFile->findPrevious($types, $start, $end, $exclude, $value, $local);
134
135	103	return $this->preparePointer($pointer);
136		}
137
138		/**
139		* Records an error against a specific token in the file.
140		*
141		* @param string $error The error message.
142		* @param int $stackPtr The stack position where the error occurred.
143		* @param string $code A violation code unique to the sniff message.
144		* @param array $data Replacements for the error message.
145		* @param int $severity The severity level for this error. A value of 0
146		* will be converted into the default severity level.
147		* @param bool $fixable Can the error be fixed by the sniff?
148		*
149		* @return bool Returns true if setting the error was done or false
150		*
151		* @SuppressWarnings(PHPMD.BooleanArgumentFlag)
152		*/
153	47	public function addError(
154		string $error,
155		int $stackPtr,
156		string $code = '',
157		array $data = [],
158		int $severity = 0,
159		bool $fixable = false
160		): bool {
161	47	return $this->baseFile->addError($error, $stackPtr, $code, $data, $severity, $fixable);
162		}
163
164		/**
165		* Records an error against a specific line in the file.
166		*
167		* @param string $error The error message.
168		* @param int $line The line on which the error occurred.
169		* @param string $code A violation code unique to the sniff message.
170		* @param array $data Replacements for the error message.
171		* @param int $severity The severity level for this error. A value of 0
172		* will be converted into the default severity level.
173		*
174		* @return bool Returns true of the error got recorded
175		*/
176	9	public function addErrorOnLine(
177		string $error,
178		int $line,
179		string $code = '',
180		array $data = [],
181		int $severity = 0
182		): bool {
183	9	return $this->baseFile->addErrorOnLine($error, $line, $code, $data, $severity);
184		}
185
186		/**
187		* Records a warning on the given line of the file
188		*
189		* @param string $warning The warning message
190		* @param int $stackPointer The stack position where the warning occured
191		* @param string $code The warning code
192		* @param array $data Replacements for the warning message
193		*
194		* @return bool Returns if a warning was added
195		*/
196	1	public function addWarning(
197		string $warning,
198		int $stackPointer,
199		string $code = '',
200		array $data = []
201		): bool {
202	1	return $this->baseFile->addWarning($warning, $stackPointer, $code, $data);
203		}
204
205		/**
206		* Returns the position of the next specified token(s).
207		*
208		* If a value is specified, the next token of the specified type(s)
209		* containing the specified value will be returned.
210		*
211		* Returns false if no token can be found.
212		*
213		* @param array $types The type(s) of tokens to search for.
214		* @param int $start The position to start searching from in the
215		* token stack.
216		* @param int $end The end position to fail if no token is found. if not specified or null, end will default to
217		* the end of the token stack.
218		* @param bool $exclude If true, find the next token that is NOT of a type specified in $types.
219		* @param string $value The value that the token(s) must be equal to.
220		* If value is omitted, tokens with any value will be returned.
221		* @param bool $local If true, tokens outside the current statement will not be checked. i.e., checking will stop
222		* at the next semi-colon found.
223		*
224		* @return int Returns the pointer of the token or -1
225		*
226		* @SuppressWarnings(PHPMD.BooleanArgumentFlag)
227		*/
228	97	public function findNext(
229		array $types,
230		int $start,
231		?int $end = null,
232		bool $exclude = false,
233		?string $value = null,
234		bool $local = false
235		): int {
236	97	$result = $this->baseFile->findNext($types, $start, $end, $exclude, $value, $local);
237
238	97	return $this->preparePointer($result);
239		}
240
241		/**
242		* Prepares given pointer result.
243		*
244		* @param int\|bool $pointer Pointer of a token
245		*
246		* @return int Pointer or -1 when not found
247		*/
248	103	public function preparePointer($pointer): int
249		{
250	103	return $pointer !== false ? $pointer : -1;
251		}
252
253		/**
254		* Returns the Wrapped PHP_CodeSniffer_Fixer
255		*
256		* @return Fixer Returns the wrapped PHP_CodeSniffer_Fixer
257		*/
258	33	public function getFixer(): Fixer
259		{
260	33	return $this->fixer;
261		}
262
263		/**
264		* Returns the eol char of the file
265		*
266		* @return string Returns the EndOfLine-Character of the processed file
267		*/
268	72	public function getEolChar(): string
269		{
270	72	return $this->baseFile->eolChar;
271		}
272		}
273

bestit / PHP_CodeSniffer

Pull Request — master (#20)

File::addWarning() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like