InBetweenMethodSpacingSniff::getNextLineContent() - Code Metrics - Zenify/CodingStandard - Measure and Improve Code Quality continuously with Scrutinizer

InBetweenMethodSpacingSniff::getNextLineContent() A
last analyzed 2016-12-30 16:03 UTC

↳ Parent: InBetweenMethodSpacingSniff

Complexity

Conditions	2
Paths	2

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	2.0625

Importance

Changes

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

<?php

declare(strict_types = 1);

/*
 * This file is part of Zenify
 * Copyright (c) 2012 Tomas Votruba (http://tomasvotruba.cz)
 */

namespace ZenifyCodingStandard\Sniffs\WhiteSpace;

use PHP_CodeSniffer_File;
use Squiz_Sniffs_WhiteSpace_FunctionSpacingSniff;
use ZenifyCodingStandard\Helper\Whitespace\EmptyLinesResizer;


/**
 * Rules:
 * - Method should have X empty line(s) after itself.
 *
 * Exceptions:
 * - Method is the first in the class, preceded by open bracket.
 * - Method is the last in the class, followed by close bracket.
 */
final class InBetweenMethodSpacingSniff extends Squiz_Sniffs_WhiteSpace_FunctionSpacingSniff
{

	/**
	 * @var string
	 */
	const NAME = 'ZenifyCodingStandard.WhiteSpace.InBetweenMethodSpacing';

	/**
	 * @var int
	 */
	public $blankLinesBetweenMethods = 2;

	/**
	 * @var int
	 */
	private $position;

	/**
	 * @var array
	 */
	private $tokens;

	/**
	 * @var PHP_CodeSniffer_File
	 */
	private $file;


	/**
	 * @return int[]
	 */
	public function register() : array
	{
		return [T_FUNCTION];
	}


	/**
	 * @param PHP_CodeSniffer_File $file
	 * @param int $position
	 */
	public function process(PHP_CodeSniffer_File $file, $position)
	{
		// Fix type
		$this->blankLinesBetweenMethods = (int) $this->blankLinesBetweenMethods;

		$this->file = $file;
		$this->position = $position;
		$this->tokens = $file->getTokens();

		$blankLinesCountAfterFunction = $this->getBlankLineCountAfterFunction();
		if ($blankLinesCountAfterFunction !== $this->blankLinesBetweenMethods) {
			if ($this->isLastMethod()) {
				return;

			} else {
				$error = sprintf(
					'Method should have %s empty line(s) after itself, %s found.',
					$this->blankLinesBetweenMethods,
					$blankLinesCountAfterFunction
				);
				$fix = $file->addFixableError($error, $position);
				if ($fix) {
					$this->fixSpacingAfterMethod($blankLinesCountAfterFunction);
				}
			}
		}
	}


	private function getBlankLineCountAfterFunction() : int
	{
		$closer = $this->getScopeCloser();
		$nextLineToken = $this->getNextLineTokenByScopeCloser($closer);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

		$nextContent = $this->getNextLineContent($nextLineToken);
		if ($nextContent !== FALSE) {
			$foundLines = ($this->tokens[$nextContent]['line'] - $this->tokens[$nextLineToken]['line']);

		} else {
			// We are at the end of the file.
			$foundLines = $this->blankLinesBetweenMethods;
		}

		return $foundLines;
	}


	private function isLastMethod() : bool
	{
		$closer = $this->getScopeCloser();
		$nextLineToken = $this->getNextLineTokenByScopeCloser($closer);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
		if ($this->tokens[$nextLineToken + 1]['code'] === T_CLOSE_CURLY_BRACKET) {
			return TRUE;
		}
		return FALSE;
	}


	/**
	 * @return bool|int
	 */
	private function getScopeCloser()
	{
		if (isset($this->tokens[$this->position]['scope_closer']) === FALSE) {
			// Must be an interface method, so the closer is the semi-colon.
			return $this->file->findNext(T_SEMICOLON, $this->position);
		}

		return $this->tokens[$this->position]['scope_closer'];
	}


	/**
	 * @return int|NULL
	 */
	private function getNextLineTokenByScopeCloser(int $closer)
	{
		$nextLineToken = NULL;
		for ($i = $closer; $i < $this->file->numTokens; $i++) {
			if (strpos($this->tokens[$i]['content'], $this->file->eolChar) === FALSE) {
				continue;

			} else {
				$nextLineToken = ($i + 1);
				if ( ! isset($this->tokens[$nextLineToken])) {
					$nextLineToken = NULL;
				}

				break;
			}
		}
		return $nextLineToken;
	}


	/**
	 * @return FALSE|int
	 */
	private function getNextLineContent(int $nextLineToken)
	{
		if ($nextLineToken !== NULL) {
			return $this->file->findNext(T_WHITESPACE, ($nextLineToken + 1), NULL, TRUE);
		}
		return FALSE;
	}


	private function fixSpacingAfterMethod(int $blankLinesCountAfterFunction)
	{
		EmptyLinesResizer::resizeLines(
			$this->file,
			$this->getScopeCloser() + 1,
			$blankLinesCountAfterFunction,
			$this->blankLinesBetweenMethods
		);
	}

}


1		<?php
2
3		declare(strict_types = 1);
4
5		/*
6		* This file is part of Zenify
7		* Copyright (c) 2012 Tomas Votruba (http://tomasvotruba.cz)
8		*/
9
10		namespace ZenifyCodingStandard\Sniffs\WhiteSpace;
11
12		use PHP_CodeSniffer_File;
13		use Squiz_Sniffs_WhiteSpace_FunctionSpacingSniff;
14		use ZenifyCodingStandard\Helper\Whitespace\EmptyLinesResizer;
15
16
17		/**
18		* Rules:
19		* - Method should have X empty line(s) after itself.
20		*
21		* Exceptions:
22		* - Method is the first in the class, preceded by open bracket.
23		* - Method is the last in the class, followed by close bracket.
24		*/
25		final class InBetweenMethodSpacingSniff extends Squiz_Sniffs_WhiteSpace_FunctionSpacingSniff
26		{
27
28		/**
29		* @var string
30		*/
31		const NAME = 'ZenifyCodingStandard.WhiteSpace.InBetweenMethodSpacing';
32
33		/**
34		* @var int
35		*/
36		public $blankLinesBetweenMethods = 2;
37
38		/**
39		* @var int
40		*/
41		private $position;
42
43		/**
44		* @var array
45		*/
46		private $tokens;
47
48		/**
49		* @var PHP_CodeSniffer_File
50		*/
51		private $file;
52
53
54		/**
55		* @return int[]
56		*/
57	2	public function register() : array
58		{
59	2	return [T_FUNCTION];
60		}
61
62
63		/**
64		* @param PHP_CodeSniffer_File $file
65		* @param int $position
66		*/
67	2	public function process(PHP_CodeSniffer_File $file, $position)
68		{
69		// Fix type
70	2	$this->blankLinesBetweenMethods = (int) $this->blankLinesBetweenMethods;
71
72	2	$this->file = $file;
73	2	$this->position = $position;
74	2	$this->tokens = $file->getTokens();
75
76	2	$blankLinesCountAfterFunction = $this->getBlankLineCountAfterFunction();
77	2	if ($blankLinesCountAfterFunction !== $this->blankLinesBetweenMethods) {
78	2	if ($this->isLastMethod()) {
79	2	return;
80
81		} else {
82	2	$error = sprintf(
83	2	'Method should have %s empty line(s) after itself, %s found.',
84	2	$this->blankLinesBetweenMethods,
85		$blankLinesCountAfterFunction
86		);
87	2	$fix = $file->addFixableError($error, $position);
88	2	if ($fix) {
89	1	$this->fixSpacingAfterMethod($blankLinesCountAfterFunction);
90		}
91		}
92		}
93	2	}
94
95
96	2	private function getBlankLineCountAfterFunction() : int
97		{
98	2	$closer = $this->getScopeCloser();
99	2	$nextLineToken = $this->getNextLineTokenByScopeCloser($closer);
		0 ignored issues – show Bug introduced 2016-12-29 23:29 UTC by Report Bug Copy Issue Report It seems like `$closer` defined by `$this->getScopeCloser()` on line `98` can also be of type `boolean`; however, `ZenifyCodingStandard\Sni...ineTokenByScopeCloser()` does only seem to accept `integer`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
100
101	2	$nextContent = $this->getNextLineContent($nextLineToken);
102	2	if ($nextContent !== FALSE) {
103	2	$foundLines = ($this->tokens[$nextContent]['line'] - $this->tokens[$nextLineToken]['line']);
104
105		} else {
106		// We are at the end of the file.
107		$foundLines = $this->blankLinesBetweenMethods;
108		}
109
110	2	return $foundLines;
111		}
112
113
114	2	private function isLastMethod() : bool
115		{
116	2	$closer = $this->getScopeCloser();
117	2	$nextLineToken = $this->getNextLineTokenByScopeCloser($closer);
		0 ignored issues – show Bug introduced 2016-12-29 23:29 UTC by Report Bug Copy Issue Report It seems like `$closer` defined by `$this->getScopeCloser()` on line `116` can also be of type `boolean`; however, `ZenifyCodingStandard\Sni...ineTokenByScopeCloser()` does only seem to accept `integer`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
118	2	if ($this->tokens[$nextLineToken + 1]['code'] === T_CLOSE_CURLY_BRACKET) {
119	2	return TRUE;
120		}
121	2	return FALSE;
122		}
123
124
125		/**
126		* @return bool\|int
127		*/
128	2	private function getScopeCloser()
129		{
130	2	if (isset($this->tokens[$this->position]['scope_closer']) === FALSE) {
131		// Must be an interface method, so the closer is the semi-colon.
132		return $this->file->findNext(T_SEMICOLON, $this->position);
133		}
134
135	2	return $this->tokens[$this->position]['scope_closer'];
136		}
137
138
139		/**
140		* @return int\|NULL
141		*/
142	2	private function getNextLineTokenByScopeCloser(int $closer)
143		{
144	2	$nextLineToken = NULL;
145	2	for ($i = $closer; $i < $this->file->numTokens; $i++) {
146	2	if (strpos($this->tokens[$i]['content'], $this->file->eolChar) === FALSE) {
147	2	continue;
148
149		} else {
150	2	$nextLineToken = ($i + 1);
151	2	if ( ! isset($this->tokens[$nextLineToken])) {
152		$nextLineToken = NULL;
153		}
154
155	2	break;
156		}
157		}
158	2	return $nextLineToken;
159		}
160
161
162		/**
163		* @return FALSE\|int
164		*/
165	2	private function getNextLineContent(int $nextLineToken)
166		{
167	2	if ($nextLineToken !== NULL) {
168	2	return $this->file->findNext(T_WHITESPACE, ($nextLineToken + 1), NULL, TRUE);
169		}
170		return FALSE;
171		}
172
173
174	1	private function fixSpacingAfterMethod(int $blankLinesCountAfterFunction)
175		{
176	1	EmptyLinesResizer::resizeLines(
177	1	$this->file,
178	1	$this->getScopeCloser() + 1,
179		$blankLinesCountAfterFunction,
180	1	$this->blankLinesBetweenMethods
181		);
182	1	}
183
184		}
185

Zenify / CodingStandard

InBetweenMethodSpacingSniff::getNextLineContent() A last analyzed 2016-12-30 16:03 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

InBetweenMethodSpacingSniff::getNextLineContent() A
last analyzed 2016-12-30 16:03 UTC