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

WhitespaceFormatter::applyAssignments() A
last analyzed 2019-08-17 15:06 UTC

↳ 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 {
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

WhitespaceFormatter::applyAssignments() A last analyzed 2019-08-17 15:06 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

WhitespaceFormatter::applyAssignments() A
last analyzed 2019-08-17 15:06 UTC