Squiz_Sniffs_Commenting_BlockCommentSniff - Code Metrics - Inspection of "add scrutinizer" - jazzsequence/games-collector - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 699b70...879176 )

by Chris

created 2017-04-04 23:43 UTC

Squiz_Sniffs_Commenting_BlockCommentSniff B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	328
Duplicated Lines	14.33 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

Metric	Value
dl	47
loc	328
rs	7.0642
c	0
b	0
f	0
wmc	54
lcom	1
cbo	5

2 Methods

Rating	Name	Duplication	Size	Complexity
A	register()	0	8	1
F	process()	47	290	53

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Squiz_Sniffs_Commenting_BlockCommentSniff often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Squiz_Sniffs_Commenting_BlockCommentSniff, and based on these observations, apply Extract Interface, too.

<?php
/**
 * Squiz_Sniffs_Commenting_BlockCommentSniff.
 *
 * PHP version 5
 *
 * @category  PHP
 * @package   PHP_CodeSniffer
 * @author    Greg Sherwood <[email protected]>
 * @author    Marc McIntyre <[email protected]>
 * @copyright 2006-2014 Squiz Pty Ltd (ABN 77 084 670 600)
 * @license   https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence
 * @link      http://pear.php.net/package/PHP_CodeSniffer
 */

/**
 * Squiz_Sniffs_Commenting_BlockCommentSniff.
 *
 * Verifies that block comments are used appropriately.
 *
 * @category  PHP
 * @package   PHP_CodeSniffer
 * @author    Greg Sherwood <[email protected]>
 * @author    Marc McIntyre <[email protected]>
 * @copyright 2006-2014 Squiz Pty Ltd (ABN 77 084 670 600)
 * @license   https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence
 * @version   Release: @package_version@
 * @link      http://pear.php.net/package/PHP_CodeSniffer
 */
class Squiz_Sniffs_Commenting_BlockCommentSniff implements PHP_CodeSniffer_Sniff
namespace YourVendor;

class YourClass { }
{

    /**
     * The --tab-width CLI value that is being used.
     *
     * @var int
     */
    private $_tabWidth = null;


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

    }//end register()


    /**
     * Processes this test, when one of its tokens is encountered.
     *
     * @param PHP_CodeSniffer_File $phpcsFile The current 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->_tabWidth === null) {

            $cliValues = $phpcsFile->phpcs->cli->getCommandLineValues();
            if (isset($cliValues['tabWidth']) === false || $cliValues['tabWidth'] === 0) {
                // We have no idea how wide tabs are, so assume 4 spaces for fixing.
                $this->_tabWidth = 4;
            } else {
                $this->_tabWidth = $cliValues['tabWidth'];
            }
        }

        $tokens = $phpcsFile->getTokens();

        // If it's an inline comment, return.
        if (substr($tokens[$stackPtr]['content'], 0, 2) !== '/*') {
            return;
        }

        // If this is a function/class/interface doc block comment, skip it.
        // We are only interested in inline doc block comments.
        if ($tokens[$stackPtr]['code'] === T_DOC_COMMENT_OPEN_TAG) {
            $nextToken = $phpcsFile->findNext(PHP_CodeSniffer_Tokens::$emptyTokens, ($stackPtr + 1), null, true);
            $ignore    = array(
                          T_CLASS     => true,
                          T_INTERFACE => true,
                          T_TRAIT     => true,
                          T_FUNCTION  => true,
                          T_PUBLIC    => true,
                          T_PRIVATE   => true,
                          T_FINAL     => true,
                          T_PROTECTED => true,
                          T_STATIC    => true,
                          T_ABSTRACT  => true,
                          T_CONST     => true,
                          T_VAR       => true,
                         );
            if (isset($ignore[$tokens[$nextToken]['code']]) === true) {
                return;
            }

            $prevToken = $phpcsFile->findPrevious(PHP_CodeSniffer_Tokens::$emptyTokens, ($stackPtr - 1), null, true);
            if ($tokens[$prevToken]['code'] === T_OPEN_TAG) {
                return;
            }

            $error = 'Block comments must be started with /*';
            $fix   = $phpcsFile->addFixableError($error, $stackPtr, 'WrongStart');
            if ($fix === true) {
                $phpcsFile->fixer->replaceToken($stackPtr, '/*');
            }

            $end = $tokens[$stackPtr]['comment_closer'];
            if ($tokens[$end]['content'] !== '*/') {
                $error = 'Block comments must be ended with */';
                $fix   = $phpcsFile->addFixableError($error, $end, 'WrongEnd');
                if ($fix === true) {
                    $phpcsFile->fixer->replaceToken($end, '*/');
                }
            }

            return;
        }//end if

        $commentLines  = array($stackPtr);
        $nextComment   = $stackPtr;
        $lastLine      = $tokens[$stackPtr]['line'];
        $commentString = $tokens[$stackPtr]['content'];

        // Construct the comment into an array.
        while (($nextComment = $phpcsFile->findNext(T_WHITESPACE, ($nextComment + 1), null, true)) !== false) {
            if ($tokens[$nextComment]['code'] !== $tokens[$stackPtr]['code']) {
                // Found the next bit of code.
                break;
            }

            if (($tokens[$nextComment]['line'] - 1) !== $lastLine) {
                // Not part of the block.
                break;
            }

            $lastLine       = $tokens[$nextComment]['line'];
            $commentLines[] = $nextComment;
            $commentString .= $tokens[$nextComment]['content'];
            if ($tokens[$nextComment]['code'] === T_DOC_COMMENT_CLOSE_TAG) {
                break;
            }
        }

        $commentText = str_replace($phpcsFile->eolChar, '', $commentString);
        $commentText = trim($commentText, '/* ');
        if ($commentText === '') {
            $error = 'Empty block comment not allowed';
            $fix   = $phpcsFile->addFixableError($error, $stackPtr, 'Empty');
            if ($fix === true) {
                $phpcsFile->fixer->beginChangeset();
                $phpcsFile->fixer->replaceToken($stackPtr, '');
                $lastToken = array_pop($commentLines);
                for ($i = ($stackPtr + 1); $i <= $lastToken; $i++) {
                    $phpcsFile->fixer->replaceToken($i, '');
                }

                $phpcsFile->fixer->endChangeset();
            }

            return;
        }

        if (count($commentLines) === 1) {
            $error = 'Single line block comment not allowed; use inline ("// text") comment instead';
            $fix   = $phpcsFile->addFixableError($error, $stackPtr, 'SingleLine');
            if ($fix === true) {
                $comment = '// '.$commentText.$phpcsFile->eolChar;
                $phpcsFile->fixer->replaceToken($stackPtr, $comment);
            }

            return;
        }

        $content = trim($tokens[$stackPtr]['content']);
        if ($content !== '/*' && $content !== '/**') {
            $error = 'Block comment text must start on a new line';
            $fix   = $phpcsFile->addFixableError($error, $stackPtr, 'NoNewLine');
            if ($fix === true) {
                $indent = '';
                if ($tokens[($stackPtr - 1)]['code'] === T_WHITESPACE) {
                    if (isset($tokens[($stackPtr - 1)]['orig_content']) === true) {
                        $indent = $tokens[($stackPtr - 1)]['orig_content'];
                    } else {
                        $indent = $tokens[($stackPtr - 1)]['content'];
                    }
                }

                $comment = preg_replace(
                    '/^(\s*\/\*\*?)/',
                    '$1'.$phpcsFile->eolChar.$indent,
                    $tokens[$stackPtr]['content'],
                    1
                );
                $phpcsFile->fixer->replaceToken($stackPtr, $comment);
            }

            return;
        }//end if

        $starColumn = ($tokens[$stackPtr]['column'] + 3);

        // Make sure first line isn't blank.
        if (trim($tokens[$commentLines[1]]['content']) === '') {
            $error = 'Empty line not allowed at start of comment';
            $fix   = $phpcsFile->addFixableError($error, $commentLines[1], 'HasEmptyLine');
            if ($fix === true) {
                $phpcsFile->fixer->replaceToken($commentLines[1], '');
            }
        } else {
            // Check indentation of first line.
            $content      = $tokens[$commentLines[1]]['content'];
            $commentText  = ltrim($content);
            $leadingSpace = (strlen($content) - strlen($commentText));
            if ($leadingSpace !== $starColumn) {
                $expected = $starColumn.' space';
                if ($starColumn !== 1) {
                    $expected .= 's';
                }

                $data = array(
                         $expected,
                         $leadingSpace,
                        );

                $error = 'First line of comment not aligned correctly; expected %s but found %s';
                $fix   = $phpcsFile->addFixableError($error, $commentLines[1], 'FirstLineIndent', $data);
                if ($fix === true) {

                    if (isset($tokens[$commentLines[1]]['orig_content']) === true
                        && $tokens[$commentLines[1]]['orig_content'][0] === "\t"
                    ) {
                        // Line is indented using tabs.
                        $padding = str_repeat("\t", floor($starColumn / $this->_tabWidth));
                    } else {
                        $padding = str_repeat(' ', $starColumn);
                    }

                    $phpcsFile->fixer->replaceToken($commentLines[1], $padding.ltrim($content));
                }
            }//end if

            if (preg_match('/^\p{Ll}/u', $commentText) === 1) {
                $error = 'Block comments must start with a capital letter';
                $phpcsFile->addError($error, $commentLines[1], 'NoCapital');
            }
        }//end if

        // Check that each line of the comment is indented past the star.
        foreach ($commentLines as $line) {
            $leadingSpace = (strlen($tokens[$line]['content']) - strlen(ltrim($tokens[$line]['content'])));
            // First and last lines (comment opener and closer) are handled separately.
            if ($line === $commentLines[(count($commentLines) - 1)] || $line === $commentLines[0]) {
                continue;
            }

            // First comment line was handled above.
            if ($line === $commentLines[1]) {
                continue;
            }

            // If it's empty, continue.
            if (trim($tokens[$line]['content']) === '') {
                continue;
            }

            if ($leadingSpace < $starColumn) {
                $expected = $starColumn.' space';
                if ($starColumn !== 1) {
                    $expected .= 's';
                }

                $data = array(
                         $expected,
                         $leadingSpace,
                        );

                $error = 'Comment line indented incorrectly; expected at least %s but found %s';
                $fix   = $phpcsFile->addFixableError($error, $line, 'LineIndent', $data);
                if ($fix === true) {

                    if (isset($tokens[$line]['orig_content']) === true
                        && $tokens[$line]['orig_content'][0] === "\t"
                    ) {
                        // Line is indented using tabs.
                        $padding = str_repeat("\t", floor($starColumn / $this->_tabWidth));
                    } else {
                        $padding = str_repeat(' ', $starColumn);
                    }

                    $phpcsFile->fixer->replaceToken($line, $padding.ltrim($tokens[$line]['content']));
                }
            }//end if
        }//end foreach

        // Finally, test the last line is correct.
        $lastIndex = (count($commentLines) - 1);
        $content   = trim($tokens[$commentLines[$lastIndex]]['content']);
        if ($content !== '*/' && $content !== '**/') {
            $error = 'Comment closer must be on a new line';
            $phpcsFile->addError($error, $commentLines[$lastIndex]);
        } else {
            $content      = $tokens[$commentLines[$lastIndex]]['content'];
            $commentText  = ltrim($content);
            $leadingSpace = (strlen($content) - strlen($commentText));
            if ($leadingSpace !== ($tokens[$stackPtr]['column'] - 1)) {
                $expected = ($tokens[$stackPtr]['column'] - 1);
                if ($expected === 1) {
                    $expected .= ' space';
                } else {
                    $expected .= ' spaces';
                }

                $data = array(
                         $expected,
                         $leadingSpace,
                        );

                $error = 'Last line of comment aligned incorrectly; expected %s but found %s';
                $phpcsFile->addError($error, $commentLines[$lastIndex], 'LastLineIndent', $data);
            }
        }//end if

        // Check that the lines before and after this comment are blank.
        $contentBefore = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true);
        if (isset($tokens[$contentBefore]['scope_closer']) === true
            && $tokens[$contentBefore]['scope_opener'] === $contentBefore
        ) {
            if (($tokens[$stackPtr]['line'] - $tokens[$contentBefore]['line']) !== 1) {

                $error = 'Empty line not required before block comment';
                $phpcsFile->addError($error, $stackPtr, 'HasEmptyLineBefore');
            }
        } else {

            if (($tokens[$stackPtr]['line'] - $tokens[$contentBefore]['line']) < 2) {
                $error = 'Empty line required before block comment';
                $phpcsFile->addError($error, $stackPtr, 'NoEmptyLineBefore');
            }
        }

        $commentCloser = $commentLines[$lastIndex];
        $contentAfter  = $phpcsFile->findNext(T_WHITESPACE, ($commentCloser + 1), null, true);
        if ($contentAfter !== false && ($tokens[$contentAfter]['line'] - $tokens[$commentCloser]['line']) < 2) {

            $error = 'Empty line required after block comment';
            $phpcsFile->addError($error, $commentCloser, 'NoEmptyLineAfter');
        }

    }//end process()


}//end class


1		<?php
2		/**
3		* Squiz_Sniffs_Commenting_BlockCommentSniff.
4		*
5		* PHP version 5
6		*
7		* @category PHP
8		* @package PHP_CodeSniffer
9		* @author Greg Sherwood <[email protected]>
10		* @author Marc McIntyre <[email protected]>
11		* @copyright 2006-2014 Squiz Pty Ltd (ABN 77 084 670 600)
12		* @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence
13		* @link http://pear.php.net/package/PHP_CodeSniffer
14		*/
15
16		/**
17		* Squiz_Sniffs_Commenting_BlockCommentSniff.
18		*
19		* Verifies that block comments are used appropriately.
20		*
21		* @category PHP
22		* @package PHP_CodeSniffer
23		* @author Greg Sherwood <[email protected]>
24		* @author Marc McIntyre <[email protected]>
25		* @copyright 2006-2014 Squiz Pty Ltd (ABN 77 084 670 600)
26		* @license https://github.com/squizlabs/PHP_CodeSniffer/blob/master/licence.txt BSD Licence
27		* @version Release: @package_version@
28		* @link http://pear.php.net/package/PHP_CodeSniffer
29		*/
30		class Squiz_Sniffs_Commenting_BlockCommentSniff implements PHP_CodeSniffer_Sniff
		0 ignored issues – show Coding Style Compatibility introduced 2017-04-04 23:55 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...
31		{
32
33		/**
34		* The --tab-width CLI value that is being used.
35		*
36		* @var int
37		*/
38		private $_tabWidth = null;
39
40
41		/**
42		* Returns an array of tokens this test wants to listen for.
43		*
44		* @return array
45		*/
46		public function register()
47		{
48		return array(
49		T_COMMENT,
50		T_DOC_COMMENT_OPEN_TAG,
51		);
52
53		}//end register()
54
55
56		/**
57		* Processes this test, when one of its tokens is encountered.
58		*
59		* @param PHP_CodeSniffer_File $phpcsFile The current file being scanned.
60		* @param int $stackPtr The position of the current token in the
61		* stack passed in $tokens.
62		*
63		* @return void
64		*/
65		public function process(PHP_CodeSniffer_File $phpcsFile, $stackPtr)
66		{
67	View Code Duplication	if ($this->_tabWidth === null) {
		0 ignored issues – show Duplication introduced 2017-04-04 23:55 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...
68		$cliValues = $phpcsFile->phpcs->cli->getCommandLineValues();
69		if (isset($cliValues['tabWidth']) === false \|\| $cliValues['tabWidth'] === 0) {
70		// We have no idea how wide tabs are, so assume 4 spaces for fixing.
71		$this->_tabWidth = 4;
72		} else {
73		$this->_tabWidth = $cliValues['tabWidth'];
74		}
75		}
76
77		$tokens = $phpcsFile->getTokens();
78
79		// If it's an inline comment, return.
80		if (substr($tokens[$stackPtr]['content'], 0, 2) !== '/*') {
81		return;
82		}
83
84		// If this is a function/class/interface doc block comment, skip it.
85		// We are only interested in inline doc block comments.
86		if ($tokens[$stackPtr]['code'] === T_DOC_COMMENT_OPEN_TAG) {
87		$nextToken = $phpcsFile->findNext(PHP_CodeSniffer_Tokens::$emptyTokens, ($stackPtr + 1), null, true);
88		$ignore = array(
89		T_CLASS => true,
90		T_INTERFACE => true,
91		T_TRAIT => true,
92		T_FUNCTION => true,
93		T_PUBLIC => true,
94		T_PRIVATE => true,
95		T_FINAL => true,
96		T_PROTECTED => true,
97		T_STATIC => true,
98		T_ABSTRACT => true,
99		T_CONST => true,
100		T_VAR => true,
101		);
102		if (isset($ignore[$tokens[$nextToken]['code']]) === true) {
103		return;
104		}
105
106		$prevToken = $phpcsFile->findPrevious(PHP_CodeSniffer_Tokens::$emptyTokens, ($stackPtr - 1), null, true);
107		if ($tokens[$prevToken]['code'] === T_OPEN_TAG) {
108		return;
109		}
110
111		$error = 'Block comments must be started with /*';
112		$fix = $phpcsFile->addFixableError($error, $stackPtr, 'WrongStart');
113		if ($fix === true) {
114		$phpcsFile->fixer->replaceToken($stackPtr, '/*');
115		}
116
117		$end = $tokens[$stackPtr]['comment_closer'];
118		if ($tokens[$end]['content'] !== '*/') {
119		$error = 'Block comments must be ended with */';
120		$fix = $phpcsFile->addFixableError($error, $end, 'WrongEnd');
121		if ($fix === true) {
122		$phpcsFile->fixer->replaceToken($end, '*/');
123		}
124		}
125
126		return;
127		}//end if
128
129		$commentLines = array($stackPtr);
130		$nextComment = $stackPtr;
131		$lastLine = $tokens[$stackPtr]['line'];
132		$commentString = $tokens[$stackPtr]['content'];
133
134		// Construct the comment into an array.
135		while (($nextComment = $phpcsFile->findNext(T_WHITESPACE, ($nextComment + 1), null, true)) !== false) {
136		if ($tokens[$nextComment]['code'] !== $tokens[$stackPtr]['code']) {
137		// Found the next bit of code.
138		break;
139		}
140
141		if (($tokens[$nextComment]['line'] - 1) !== $lastLine) {
142		// Not part of the block.
143		break;
144		}
145
146		$lastLine = $tokens[$nextComment]['line'];
147		$commentLines[] = $nextComment;
148		$commentString .= $tokens[$nextComment]['content'];
149		if ($tokens[$nextComment]['code'] === T_DOC_COMMENT_CLOSE_TAG) {
150		break;
151		}
152		}
153
154		$commentText = str_replace($phpcsFile->eolChar, '', $commentString);
155		$commentText = trim($commentText, '/* ');
156		if ($commentText === '') {
157		$error = 'Empty block comment not allowed';
158		$fix = $phpcsFile->addFixableError($error, $stackPtr, 'Empty');
159		if ($fix === true) {
160		$phpcsFile->fixer->beginChangeset();
161		$phpcsFile->fixer->replaceToken($stackPtr, '');
162		$lastToken = array_pop($commentLines);
163		for ($i = ($stackPtr + 1); $i <= $lastToken; $i++) {
164		$phpcsFile->fixer->replaceToken($i, '');
165		}
166
167		$phpcsFile->fixer->endChangeset();
168		}
169
170		return;
171		}
172
173		if (count($commentLines) === 1) {
174		$error = 'Single line block comment not allowed; use inline ("// text") comment instead';
175		$fix = $phpcsFile->addFixableError($error, $stackPtr, 'SingleLine');
176		if ($fix === true) {
177		$comment = '// '.$commentText.$phpcsFile->eolChar;
178		$phpcsFile->fixer->replaceToken($stackPtr, $comment);
179		}
180
181		return;
182		}
183
184		$content = trim($tokens[$stackPtr]['content']);
185		if ($content !== '/' && $content !== '/*') {
186		$error = 'Block comment text must start on a new line';
187		$fix = $phpcsFile->addFixableError($error, $stackPtr, 'NoNewLine');
188		if ($fix === true) {
189		$indent = '';
190		if ($tokens[($stackPtr - 1)]['code'] === T_WHITESPACE) {
191		if (isset($tokens[($stackPtr - 1)]['orig_content']) === true) {
192		$indent = $tokens[($stackPtr - 1)]['orig_content'];
193		} else {
194		$indent = $tokens[($stackPtr - 1)]['content'];
195		}
196		}
197
198		$comment = preg_replace(
199		'/^(\s\/\\*?)/',
200		'$1'.$phpcsFile->eolChar.$indent,
201		$tokens[$stackPtr]['content'],
202		1
203		);
204		$phpcsFile->fixer->replaceToken($stackPtr, $comment);
205		}
206
207		return;
208		}//end if
209
210		$starColumn = ($tokens[$stackPtr]['column'] + 3);
211
212		// Make sure first line isn't blank.
213		if (trim($tokens[$commentLines[1]]['content']) === '') {
214		$error = 'Empty line not allowed at start of comment';
215		$fix = $phpcsFile->addFixableError($error, $commentLines[1], 'HasEmptyLine');
216		if ($fix === true) {
217		$phpcsFile->fixer->replaceToken($commentLines[1], '');
218		}
219		} else {
220		// Check indentation of first line.
221		$content = $tokens[$commentLines[1]]['content'];
222		$commentText = ltrim($content);
223		$leadingSpace = (strlen($content) - strlen($commentText));
224		if ($leadingSpace !== $starColumn) {
225		$expected = $starColumn.' space';
226		if ($starColumn !== 1) {
227		$expected .= 's';
228		}
229
230		$data = array(
231		$expected,
232		$leadingSpace,
233		);
234
235		$error = 'First line of comment not aligned correctly; expected %s but found %s';
236		$fix = $phpcsFile->addFixableError($error, $commentLines[1], 'FirstLineIndent', $data);
237	View Code Duplication	if ($fix === true) {
		0 ignored issues – show Duplication introduced 2017-04-04 23:55 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...
238		if (isset($tokens[$commentLines[1]]['orig_content']) === true
239		&& $tokens[$commentLines[1]]['orig_content'][0] === "\t"
240		) {
241		// Line is indented using tabs.
242		$padding = str_repeat("\t", floor($starColumn / $this->_tabWidth));
243		} else {
244		$padding = str_repeat(' ', $starColumn);
245		}
246
247		$phpcsFile->fixer->replaceToken($commentLines[1], $padding.ltrim($content));
248		}
249		}//end if
250
251		if (preg_match('/^\p{Ll}/u', $commentText) === 1) {
252		$error = 'Block comments must start with a capital letter';
253		$phpcsFile->addError($error, $commentLines[1], 'NoCapital');
254		}
255		}//end if
256
257		// Check that each line of the comment is indented past the star.
258		foreach ($commentLines as $line) {
259		$leadingSpace = (strlen($tokens[$line]['content']) - strlen(ltrim($tokens[$line]['content'])));
260		// First and last lines (comment opener and closer) are handled separately.
261		if ($line === $commentLines[(count($commentLines) - 1)] \|\| $line === $commentLines[0]) {
262		continue;
263		}
264
265		// First comment line was handled above.
266		if ($line === $commentLines[1]) {
267		continue;
268		}
269
270		// If it's empty, continue.
271		if (trim($tokens[$line]['content']) === '') {
272		continue;
273		}
274
275		if ($leadingSpace < $starColumn) {
276		$expected = $starColumn.' space';
277		if ($starColumn !== 1) {
278		$expected .= 's';
279		}
280
281		$data = array(
282		$expected,
283		$leadingSpace,
284		);
285
286		$error = 'Comment line indented incorrectly; expected at least %s but found %s';
287		$fix = $phpcsFile->addFixableError($error, $line, 'LineIndent', $data);
288	View Code Duplication	if ($fix === true) {
		0 ignored issues – show Duplication introduced 2017-04-04 23:55 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...
289		if (isset($tokens[$line]['orig_content']) === true
290		&& $tokens[$line]['orig_content'][0] === "\t"
291		) {
292		// Line is indented using tabs.
293		$padding = str_repeat("\t", floor($starColumn / $this->_tabWidth));
294		} else {
295		$padding = str_repeat(' ', $starColumn);
296		}
297
298		$phpcsFile->fixer->replaceToken($line, $padding.ltrim($tokens[$line]['content']));
299		}
300		}//end if
301		}//end foreach
302
303		// Finally, test the last line is correct.
304		$lastIndex = (count($commentLines) - 1);
305		$content = trim($tokens[$commentLines[$lastIndex]]['content']);
306		if ($content !== '/' && $content !== '*/') {
307		$error = 'Comment closer must be on a new line';
308		$phpcsFile->addError($error, $commentLines[$lastIndex]);
309		} else {
310		$content = $tokens[$commentLines[$lastIndex]]['content'];
311		$commentText = ltrim($content);
312		$leadingSpace = (strlen($content) - strlen($commentText));
313		if ($leadingSpace !== ($tokens[$stackPtr]['column'] - 1)) {
314		$expected = ($tokens[$stackPtr]['column'] - 1);
315		if ($expected === 1) {
316		$expected .= ' space';
317		} else {
318		$expected .= ' spaces';
319		}
320
321		$data = array(
322		$expected,
323		$leadingSpace,
324		);
325
326		$error = 'Last line of comment aligned incorrectly; expected %s but found %s';
327		$phpcsFile->addError($error, $commentLines[$lastIndex], 'LastLineIndent', $data);
328		}
329		}//end if
330
331		// Check that the lines before and after this comment are blank.
332		$contentBefore = $phpcsFile->findPrevious(T_WHITESPACE, ($stackPtr - 1), null, true);
333		if (isset($tokens[$contentBefore]['scope_closer']) === true
334		&& $tokens[$contentBefore]['scope_opener'] === $contentBefore
335		) {
336	View Code Duplication	if (($tokens[$stackPtr]['line'] - $tokens[$contentBefore]['line']) !== 1) {
		0 ignored issues – show Duplication introduced 2017-04-04 23:55 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...
337		$error = 'Empty line not required before block comment';
338		$phpcsFile->addError($error, $stackPtr, 'HasEmptyLineBefore');
339		}
340	View Code Duplication	} else {
		0 ignored issues – show Duplication introduced 2017-04-04 23:55 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...
341		if (($tokens[$stackPtr]['line'] - $tokens[$contentBefore]['line']) < 2) {
342		$error = 'Empty line required before block comment';
343		$phpcsFile->addError($error, $stackPtr, 'NoEmptyLineBefore');
344		}
345		}
346
347		$commentCloser = $commentLines[$lastIndex];
348		$contentAfter = $phpcsFile->findNext(T_WHITESPACE, ($commentCloser + 1), null, true);
349	View Code Duplication	if ($contentAfter !== false && ($tokens[$contentAfter]['line'] - $tokens[$commentCloser]['line']) < 2) {
		0 ignored issues – show Duplication introduced 2017-04-04 23:55 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...
350		$error = 'Empty line required after block comment';
351		$phpcsFile->addError($error, $commentCloser, 'NoEmptyLineAfter');
352		}
353
354		}//end process()
355
356
357		}//end class
358

jazzsequence / games-collector

GitHub Access Token became invalid