WhitespaceFormatter::applyAssignments() - Code Metrics - Inspection of "fix constructor" - gossi/php-code-formatter - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( fef961...cb7bad )

by Thomas

created 2018-08-04 20:38 UTC

WhitespaceFormatter::applyAssignments() A

↳ Parent: WhitespaceFormatter

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	5
ccs	4
cts	4
cp	1
rs	10
c	0
b	0
f	0
cc	2
nc	2
nop	1
crap	2

<?php
namespace gossi\formatter\formatters;

use gossi\formatter\entities\Group;
use phootwork\tokenizer\Token;

class WhitespaceFormatter extends SpecializedFormatter {


	private static $BLOCK_CONTEXT_MAPPING = [
		T_IF => 'ifelse',
		T_ELSEIF => 'ifelse',
		T_WHILE => 'while',
		T_FOREACH => 'foreach',
		T_FOR => 'for',
		T_CATCH => 'catch'
	];

	private static $SYNTAX = [
		')' => 'close',
		'(' => 'open',
		',' => 'comma',
		';' => 'semicolon',
		':' => 'colon',
		'=>' => 'arrow',
		'->' => 'arrow', // function invocation
		'::' => 'doublecolon', // function invocation
		'?' => 'questionmark'
	];

	protected function doVisitToken(Token $token) {
		$this->applyKeywords($token);
		$this->applyAssignments($token);
		$this->applyOperators($token);
		$this->applyPrefixPostfix($token);
		$this->applyUnary($token);
class User
{
    private $email;

    public function getEmail()
    {
        return $this->email;
    }

    public function setEmail($email)
    {
        $this->email = $email;
    }
}
		$this->applySyntax($token);
	}

	private function applyKeywords(Token $token) {
		if ($this->matcher->isKeyword($token)) {
			$this->defaultFormatter->addPostWrite(' ');
		}
	}

	private function applyAssignments(Token $token) {
		if ($this->matcher->isAssignment($token)) {
			$this->whitespaceBeforeAfter('assignment', 'assignments');
		}
	}

	private function applyOperators(Token $token) {
		if ($this->matcher->isOperator($token)) {
			$this->whitespaceBeforeAfter('binary', 'operators');
		}
	}

	private function applyPrefixPostfix(Token $token) {
		if ($token->type == T_INC || $token->type == T_DEC) {
			// pre
			if ($this->nextToken->type == T_VAR) {
				$this->whitespaceBeforeAfter('prefix', 'operators');
			}

			// post
			else if ($this->prevToken->type == T_VAR) {
				$this->whitespaceBeforeAfter('postfix', 'operators');
			}
		}
	}

	/**
	 * @TODO
	 * @param Token $token
	 */
	private function applyUnary(Token $token) {


	}

	private function applySyntax(Token $token) {
		if (array_key_exists($token->contents, self::$SYNTAX)) {
			$key = self::$SYNTAX[$token->contents];
			$group = $this->context->getGroupContext();

			// return when semicolon is not inside a block context
			if ($token->contents == ';' && $group->type != Group::BLOCK) {
				return;
			}

			// anyway find context and apply it
			$context = $this->findContext($token);
			$this->whitespaceBeforeAfter($key, $context);
		}
	}

	private function findContext(Token $token) {

		$group = $this->context->getGroupContext();
		$context = 'default';

		// first check the context of the current line
		$line = $this->context->getLineContext();
		if (!empty($line)) {
			$context = $line;
		}

		// is it a parens group?
		else if ($group->type == Group::GROUP) {
			$context = 'grouping';
		}

		// a function call?
		else if ($group->type == Group::CALL) {
			$context = 'function_invocation';
		}

		// field access?
		else if ($token->contents === '->' || $token->contents === '::') {
			$context = 'field_access';
		}

		// or a given block statement?
		else if ($group->type == Group::BLOCK
				&& isset(self::$BLOCK_CONTEXT_MAPPING[$group->token->type])) {
			$context = self::$BLOCK_CONTEXT_MAPPING[$group->token->type];
		}

		return $context;
	}

	private function whitespaceBeforeAfter($key, $context = 'default') {
		if ($this->config->getWhitespace('before_' . $key, $context)) {
			$this->defaultFormatter->addPreWrite(' ');
		}

		if ($this->config->getWhitespace('after_' . $key, $context)) {
			$this->defaultFormatter->addPostWrite(' ');
		}
	}

}


1		<?php
2		namespace gossi\formatter\formatters;
3
4		use gossi\formatter\entities\Group;
5		use phootwork\tokenizer\Token;
6
7		class WhitespaceFormatter extends SpecializedFormatter {
		0 ignored issues – show Coding Style introduced 2016-05-24 10:43 UTC by Report Bug Copy Issue Report The property $BLOCK_CONTEXT_MAPPING is not named in camelCase. This check marks property names that have not been written in camelCase. In camelCase names are written without any punctuation, the start of each new word being marked by a capital letter. Thus the name database connection string becomes `databaseConnectionString`. Loading history...
8
9		private static $BLOCK_CONTEXT_MAPPING = [
10		T_IF => 'ifelse',
11		T_ELSEIF => 'ifelse',
12		T_WHILE => 'while',
13		T_FOREACH => 'foreach',
14		T_FOR => 'for',
15		T_CATCH => 'catch'
16		];
17
18		private static $SYNTAX = [
19		')' => 'close',
20		'(' => 'open',
21		',' => 'comma',
22		';' => 'semicolon',
23		':' => 'colon',
24		'=>' => 'arrow',
25		'->' => 'arrow', // function invocation
26		'::' => 'doublecolon', // function invocation
27		'?' => 'questionmark'
28		];
29
30	2	protected function doVisitToken(Token $token) {
31	2	$this->applyKeywords($token);
32	2	$this->applyAssignments($token);
33	2	$this->applyOperators($token);
34	2	$this->applyPrefixPostfix($token);
35	2	$this->applyUnary($token);
		0 ignored issues – show Unused Code introduced 2016-05-24 10:43 UTC by Report Bug Copy Issue Report The call to the method `gossi\formatter\formatte...Formatter::applyUnary()` seems un-needed as the method has no side-effects. PHP Analyzer performs a side-effects analysis of your code. A side-effect is basically anything that might be visible after the scope of the method is left. Let’s take a look at an example: class User { private $email; public function getEmail() { return $this->email; } public function setEmail($email) { $this->email = $email; } } If we look at the `getEmail()` method, we can see that it has no side-effect. Whether you call this method or not, no future calls to other methods are affected by this. As such code as the following is useless: $user = new User(); $user->getEmail(); // This line could safely be removed as it has no effect. On the hand, if we look at the `setEmail()`, this method _has_ side-effects. In the following case, we could not remove the method call: $user = new User(); $user->setEmail('email@domain'); // This line has a side-effect (it changes an // instance variable). Loading history...
36	2	$this->applySyntax($token);
37	2	}
38
39	2	private function applyKeywords(Token $token) {
40	2	if ($this->matcher->isKeyword($token)) {
41	1	$this->defaultFormatter->addPostWrite(' ');
42		}
43	2	}
44
45	2	private function applyAssignments(Token $token) {
46	2	if ($this->matcher->isAssignment($token)) {
47	2	$this->whitespaceBeforeAfter('assignment', 'assignments');
48		}
49	2	}
50
51	2	private function applyOperators(Token $token) {
52	2	if ($this->matcher->isOperator($token)) {
53	2	$this->whitespaceBeforeAfter('binary', 'operators');
54		}
55	2	}
56
57	2	private function applyPrefixPostfix(Token $token) {
58	2	if ($token->type == T_INC \|\| $token->type == T_DEC) {
59		// pre
60	1	if ($this->nextToken->type == T_VAR) {
61		$this->whitespaceBeforeAfter('prefix', 'operators');
62		}
63
64		// post
65	1	else if ($this->prevToken->type == T_VAR) {
66		$this->whitespaceBeforeAfter('postfix', 'operators');
67		}
68		}
69	2	}
70
71		/**
72		* @TODO
73		* @param Token $token
74		*/
75	2	private function applyUnary(Token $token) {
		0 ignored issues – show Unused Code introduced 2018-08-04 17:00 UTC by Report Bug Copy Issue Report The parameter `$token` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
76
77	2	}
78
79	2	private function applySyntax(Token $token) {
80	2	if (array_key_exists($token->contents, self::$SYNTAX)) {
81	2	$key = self::$SYNTAX[$token->contents];
82	2	$group = $this->context->getGroupContext();
83
84		// return when semicolon is not inside a block context
85	2	if ($token->contents == ';' && $group->type != Group::BLOCK) {
86	2	return;
87		}
88
89		// anyway find context and apply it
90	2	$context = $this->findContext($token);
91	2	$this->whitespaceBeforeAfter($key, $context);
92		}
93	2	}
94
95	2	private function findContext(Token $token) {
		0 ignored issues – show Documentation introduced 2018-08-04 17:00 UTC by Report Bug Copy Issue Report The return type could not be reliably inferred; please add a `@return` annotation. Our type inference engine in quite powerful, but sometimes the code does not provide enough clues to go by. In these cases we request you to add a `@return` annotation as described here. Loading history...
96	2	$group = $this->context->getGroupContext();
97	2	$context = 'default';
98
99		// first check the context of the current line
100	2	$line = $this->context->getLineContext();
101	2	if (!empty($line)) {
102		$context = $line;
103		}
104
105		// is it a parens group?
106	2	else if ($group->type == Group::GROUP) {
107	1	$context = 'grouping';
108		}
109
110		// a function call?
111	2	else if ($group->type == Group::CALL) {
112	2	$context = 'function_invocation';
113		}
114
115		// field access?
116	2	else if ($token->contents === '->' \|\| $token->contents === '::') {
117	1	$context = 'field_access';
118		}
119
120		// or a given block statement?
121	2	else if ($group->type == Group::BLOCK
122	2	&& isset(self::$BLOCK_CONTEXT_MAPPING[$group->token->type])) {
123	2	$context = self::$BLOCK_CONTEXT_MAPPING[$group->token->type];
124		}
125
126	2	return $context;
127		}
128
129	2	private function whitespaceBeforeAfter($key, $context = 'default') {
130	2	if ($this->config->getWhitespace('before_' . $key, $context)) {
131	2	$this->defaultFormatter->addPreWrite(' ');
132		}
133
134	2	if ($this->config->getWhitespace('after_' . $key, $context)) {
135	2	$this->defaultFormatter->addPostWrite(' ');
136		}
137	2	}
138
139		}
140

gossi / php-code-formatter

Push — master ( fef961...cb7bad )

WhitespaceFormatter::applyAssignments() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like