Formatter - Code Metrics - Inspection of "Bump Symfony to 2.7 + Add AppVeyor support" - egeloen/ivory-google-map - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#220)

by Eric

created 2017-02-26 00:00 UTC

Formatter B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	399
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

Metric	Value
wmc	43
lcom	1
cbo	1
dl	0
loc	399
ccs	122
cts	122
cp	1
rs	8.3157
c	0
b	0
f	0

24 Methods

Rating	Name	Size	Complexity
A	__construct()	5	1
A	isDebug()	4	1
A	setDebug()	4	1
A	getIndentationStep()	4	1
A	setIndentationStep()	4	1
A	renderClass()	12	3
A	renderConstant()	4	1
A	renderObject()	14	1
A	renderProperty()	8	2
A	renderObjectCall()	14	1
A	renderCall()	8	1
A	renderClosure()	19	4
A	renderObjectAssignment()	8	1
A	renderContainerAssignment()	15	1
A	renderContainerVariable()	17	3
A	renderAssignment()	6	1
A	renderStatement()	19	3
A	renderCode()	8	2
A	renderIndentation()	9	3
A	renderLines()	11	3
A	renderLine()	8	4
A	renderEscape()	4	1
A	renderSeparator()	4	2
A	renderArguments()	4	1

How to fix Complexity

<?php

/*
 * This file is part of the Ivory Google Map package.
 *
 * (c) Eric GELOEN <[email protected]>
 *
 * For the full copyright and license information, please read the LICENSE
 * file that was distributed with this source declaration.
 */

namespace Ivory\GoogleMap\Helper\Formatter;

use Ivory\GoogleMap\Utility\VariableAwareInterface;

/**
 * @author GeLo <[email protected]>
 */
class Formatter
{
    /**
     * @var bool
     */
    private $debug;

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

    /**
     * @param bool $debug
     * @param int  $indentationStep
     */
    public function __construct($debug = false, $indentationStep = 4)
    {
        $this->setDebug($debug);
        $this->setIndentationStep($indentationStep);
    }

    /**
     * @return bool
     */
    public function isDebug()
    {
        return $this->debug;
    }

    /**
     * @param bool $debug
     */
    public function setDebug($debug)
    {
        $this->debug = $debug;
    }

    /**
     * @return int
     */
    public function getIndentationStep()
    {
        return $this->indentationStep;
    }

    /**
     * @param int $indentationStep
     */
    public function setIndentationStep($indentationStep)
    {
        $this->indentationStep = $indentationStep;
    }

    /**
     * @param string|null       $name
     * @param string|false|null $namespace
     *
     * @return string
     */
    public function renderClass($name = null, $namespace = null)
    {
        if ($namespace === null) {
            $namespace = $this->renderProperty('google', 'maps');
        }

        if (empty($namespace)) {
            return $name;
        }

        return $this->renderProperty($namespace, $name);
    }

    /**
     * @param string            $class
     * @param string            $value
     * @param string|false|null $namespace
     *
     * @return string
     */
    public function renderConstant($class, $value, $namespace = null)
    {
        return $this->renderClass($this->renderProperty($class, strtoupper($value)), $namespace);
    }

    /**
     * @param string            $class
     * @param string[]          $arguments
     * @param string|false|null $namespace
     * @param bool              $semicolon
     * @param bool              $newLine
     *
     * @return string
     */
    public function renderObject(
        $class,
        array $arguments = [],
        $namespace = null,
        $semicolon = false,
        $newLine = false
    ) {
        return $this->renderCall(
            'new '.$this->renderClass($class, $namespace),
            $arguments,
            $semicolon,
            $newLine
        );
    }

    /**
     * @param string      $object
     * @param string|null $property
     *
     * @return string
     */
    public function renderProperty($object, $property = null)
    {
        if (!empty($property)) {
            $property = '.'.$property;
        }

        return $object.$property;
    }

    /**
     * @param VariableAwareInterface $object
     * @param string                 $method
     * @param string[]               $arguments
     * @param bool                   $semicolon
     * @param bool                   $newLine
     *
     * @return string
     */
    public function renderObjectCall(
        VariableAwareInterface $object,
        $method,
        array $arguments = [],
        $semicolon = false,
        $newLine = false
    ) {
        return $this->renderCall(
            $this->renderProperty($object->getVariable(), $method),
            $arguments,
            $semicolon,
            $newLine
        );
    }

    /**
     * @param string|null $method
     * @param string[]    $arguments
     * @param bool        $semicolon
     * @param bool        $newLine
     *
     * @return string
     */
    public function renderCall($method, array $arguments = [], $semicolon = false, $newLine = false)
    {
        return $this->renderCode(
            $method.$this->renderArguments($arguments),
            $semicolon,
            $newLine
        );
    }

    /**
     * @param string|null $code
     * @param string[]    $arguments
     * @param string|null $name
     * @param bool        $semicolon
     * @param bool        $newLine
     *
     * @return string
     */
    public function renderClosure(
        $code = null,
        array $arguments = [],
        $name = null,
        $semicolon = false,
        $newLine = false
    ) {
        $separator = $this->renderSeparator();

        if ($name !== null) {
            $name = ' '.$name;
        }

        return $this->renderCode($this->renderLines([
            'function'.$name.$separator.$this->renderArguments($arguments).$separator.'{',
            $this->renderIndentation($code),
            '}',
        ], !empty($code), $newLine && !$semicolon), $semicolon, $newLine && $semicolon);
    }

    /**
     * @param VariableAwareInterface $object
     * @param string                 $declaration
     * @param bool                   $semicolon
     * @param bool                   $newLine
     *
     * @return string
     */
    public function renderObjectAssignment(
        VariableAwareInterface $object,
        $declaration,
        $semicolon = false,
        $newLine = false
    ) {
        return $this->renderAssignment($object->getVariable(), $declaration, $semicolon, $newLine);
    }

    /**
     * @param VariableAwareInterface      $root
     * @param string                      $declaration
     * @param string|null                 $propertyPath
     * @param VariableAwareInterface|null $object
     * @param bool                        $semicolon
     * @param bool                        $newLine
     *
     * @return string
     */
    public function renderContainerAssignment(
        VariableAwareInterface $root,
        $declaration,
        $propertyPath = null,
        VariableAwareInterface $object = null,
        $semicolon = true,
        $newLine = true
    ) {
        return $this->renderAssignment(
            $this->renderContainerVariable($root, $propertyPath, $object),
            $declaration,
            $semicolon,
            $newLine
        );
    }

    /**
     * @param VariableAwareInterface      $root
     * @param string|null                 $propertyPath
     * @param VariableAwareInterface|null $object
     *
     * @return string
     */
    public function renderContainerVariable(
        VariableAwareInterface $root,
        $propertyPath = null,
        VariableAwareInterface $object = null
    ) {
        $variable = $root->getVariable().'_container';

        if ($propertyPath !== null) {
            $variable = $this->renderProperty($variable, $propertyPath);
        }

        if ($object !== null) {
            $variable = $this->renderProperty($variable, $object->getVariable());
        }

        return $variable;
    }

    /**
     * @param string $variable
     * @param string $declaration
     * @param bool   $semicolon
     * @param bool   $newLine
     *
     * @return string
     */
    public function renderAssignment($variable, $declaration, $semicolon = false, $newLine = false)
    {
        $separator = $this->renderSeparator();

        return $this->renderCode($variable.$separator.'='.$separator.$declaration, $semicolon, $newLine);
    }

    /**
     * @param string      $statement
     * @param string      $code
     * @param string|null $condition
     * @param string|null $next
     * @param bool        $newLine
     *
     * @return string
     */
    public function renderStatement($statement, $code, $condition = null, $next = null, $newLine = true)
    {
        $separator = $this->renderSeparator();
        $statement .= $separator;

        if (!empty($condition)) {
            $statement .= $this->renderArguments([$condition]).$separator;
        }

        if (!empty($next)) {
            $next = $separator.$next;
        }

        return $this->renderLines([
            $statement.'{',
            $this->renderIndentation($code),
            '}'.$next,
        ], true, $newLine);
    }

    /**
     * @param string $code
     * @param bool   $semicolon
     * @param bool   $newLine
     *
     * @return string
     */
    public function renderCode($code, $semicolon = true, $newLine = true)
    {
        if ($semicolon) {
            $code .= ';';
        }

        return $this->renderLine($code, $newLine);
    }

    /**
     * @param string|null $code
     *
     * @return string
     */
    public function renderIndentation($code = null)
    {
        if ($this->debug && !empty($code)) {
            $indentation = str_repeat(' ', $this->indentationStep);
            $code = $indentation.str_replace("\n", "\n".$indentation, $code);
        }

        return (string) $code;
    }

    /**
     * @param string[] $codes
     * @param bool     $newLine
     * @param bool     $eolLine
     *
     * @return string
     */
    public function renderLines(array $codes, $newLine = true, $eolLine = true)
    {
        $result = '';
        $count = count($codes);

        for ($index = 0; $index < $count; ++$index) {
            $result .= $this->renderLine($codes[$index], $newLine && $index !== $count - 1);
        }

        return $this->renderLine($result, $eolLine);
    }

    /**
     * @param string|null $code
     * @param bool        $newLine
     *
     * @return string
     */
    public function renderLine($code = null, $newLine = true)
    {
        if ($newLine && !empty($code) && $this->debug) {
            $code .= "\n";
        }

        return (string) $code;
    }

    /**
     * @param string $argument
     *
     * @return string
     */
    public function renderEscape($argument)
    {
        return json_encode($argument, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE);
    }

    /**
     * @return string
     */
    public function renderSeparator()
    {
        return $this->debug ? ' ' : '';
    }

    /**
     * @param string[] $arguments
     *
     * @return string
     */
    private function renderArguments(array $arguments)
    {
        return '('.implode(','.$this->renderSeparator(), $arguments).')';
    }
}


GitHub Access Token became invalid

Pull Request — master (#220)

Formatter B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

24 Methods

How to fix Complexity

Complex Class

1		<?php
2
3		/*
4		* This file is part of the Ivory Google Map package.
5		*
6		* (c) Eric GELOEN <[email protected]>
7		*
8		* For the full copyright and license information, please read the LICENSE
9		* file that was distributed with this source declaration.
10		*/
11
12		namespace Ivory\GoogleMap\Helper\Formatter;
13
14		use Ivory\GoogleMap\Utility\VariableAwareInterface;
15
16		/**
17		* @author GeLo <[email protected]>
18		*/
19		class Formatter
20		{
21		/**
22		* @var bool
23		*/
24		private $debug;
25
26		/**
27		* @var int
28		*/
29		private $indentationStep;
30
31		/**
32		* @param bool $debug
33		* @param int $indentationStep
34		*/
35	1808	public function __construct($debug = false, $indentationStep = 4)
36		{
37	1808	$this->setDebug($debug);
38	1808	$this->setIndentationStep($indentationStep);
39	1808	}
40
41		/**
42		* @return bool
43		*/
44	464	public function isDebug()
45		{
46	464	return $this->debug;
47		}
48
49		/**
50		* @param bool $debug
51		*/
52	1808	public function setDebug($debug)
53		{
54	1808	$this->debug = $debug;
55	1808	}
56
57		/**
58		* @return int
59		*/
60	8	public function getIndentationStep()
61		{
62	8	return $this->indentationStep;
63		}
64
65		/**
66		* @param int $indentationStep
67		*/
68	1808	public function setIndentationStep($indentationStep)
69		{
70	1808	$this->indentationStep = $indentationStep;
71	1808	}
72
73		/**
74		* @param string\|null $name
75		* @param string\|false\|null $namespace
76		*
77		* @return string
78		*/
79	580	public function renderClass($name = null, $namespace = null)
80		{
81	580	if ($namespace === null) {
82	536	$namespace = $this->renderProperty('google', 'maps');
83	268	}
84
85	580	if (empty($namespace)) {
86	52	return $name;
87		}
88
89	564	return $this->renderProperty($namespace, $name);
90		}
91
92		/**
93		* @param string $class
94		* @param string $value
95		* @param string\|false\|null $namespace
96		*
97		* @return string
98		*/
99	320	public function renderConstant($class, $value, $namespace = null)
100		{
101	320	return $this->renderClass($this->renderProperty($class, strtoupper($value)), $namespace);
102		}
103
104		/**
105		* @param string $class
106		* @param string[] $arguments
107		* @param string\|false\|null $namespace
108		* @param bool $semicolon
109		* @param bool $newLine
110		*
111		* @return string
112		*/
113	436	public function renderObject(
114		$class,
115		array $arguments = [],
116		$namespace = null,
117		$semicolon = false,
118		$newLine = false
119		) {
120	436	return $this->renderCall(
121	436	'new '.$this->renderClass($class, $namespace),
122	218	$arguments,
123	218	$semicolon,
124		$newLine
125	218	);
126		}
127
128		/**
129		* @param string $object
130		* @param string\|null $property
131		*
132		* @return string
133		*/
134	740	public function renderProperty($object, $property = null)
135		{
136	740	if (!empty($property)) {
137	732	$property = '.'.$property;
138	366	}
139
140	740	return $object.$property;
141		}
142
143		/**
144		* @param VariableAwareInterface $object
145		* @param string $method
146		* @param string[] $arguments
147		* @param bool $semicolon
148		* @param bool $newLine
149		*
150		* @return string
151		*/
152	308	public function renderObjectCall(
153		VariableAwareInterface $object,
154		$method,
155		array $arguments = [],
156		$semicolon = false,
157		$newLine = false
158		) {
159	308	return $this->renderCall(
160	308	$this->renderProperty($object->getVariable(), $method),
161	154	$arguments,
162	154	$semicolon,
163		$newLine
164	154	);
165		}
166
167		/**
168		* @param string\|null $method
169		* @param string[] $arguments
170		* @param bool $semicolon
171		* @param bool $newLine
172		*
173		* @return string
174		*/
175	668	public function renderCall($method, array $arguments = [], $semicolon = false, $newLine = false)
176		{
177	668	return $this->renderCode(
178	668	$method.$this->renderArguments($arguments),
179	334	$semicolon,
180		$newLine
181	334	);
182		}
183
184		/**
185		* @param string\|null $code
186		* @param string[] $arguments
187		* @param string\|null $name
188		* @param bool $semicolon
189		* @param bool $newLine
190		*
191		* @return string
192		*/
193	400	public function renderClosure(
194		$code = null,
195		array $arguments = [],
196		$name = null,
197		$semicolon = false,
198		$newLine = false
199		) {
200	400	$separator = $this->renderSeparator();
201
202	400	if ($name !== null) {
203	336	$name = ' '.$name;
204	168	}
205
206	400	return $this->renderCode($this->renderLines([
207	400	'function'.$name.$separator.$this->renderArguments($arguments).$separator.'{',
208	400	$this->renderIndentation($code),
209	400	'}',
210	400	], !empty($code), $newLine && !$semicolon), $semicolon, $newLine && $semicolon);
211		}
212
213		/**
214		* @param VariableAwareInterface $object
215		* @param string $declaration
216		* @param bool $semicolon
217		* @param bool $newLine
218		*
219		* @return string
220		*/
221	468	public function renderObjectAssignment(
222		VariableAwareInterface $object,
223		$declaration,
224		$semicolon = false,
225		$newLine = false
226		) {
227	468	return $this->renderAssignment($object->getVariable(), $declaration, $semicolon, $newLine);
228		}
229
230		/**
231		* @param VariableAwareInterface $root
232		* @param string $declaration
233		* @param string\|null $propertyPath
234		* @param VariableAwareInterface\|null $object
235		* @param bool $semicolon
236		* @param bool $newLine
237		*
238		* @return string
239		*/
240	312	public function renderContainerAssignment(
241		VariableAwareInterface $root,
242		$declaration,
243		$propertyPath = null,
244		VariableAwareInterface $object = null,
245		$semicolon = true,
246		$newLine = true
247		) {
248	312	return $this->renderAssignment(
249	312	$this->renderContainerVariable($root, $propertyPath, $object),
250	156	$declaration,
251	156	$semicolon,
252		$newLine
253	156	);
254		}
255
256		/**
257		* @param VariableAwareInterface $root
258		* @param string\|null $propertyPath
259		* @param VariableAwareInterface\|null $object
260		*
261		* @return string
262		*/
263	328	public function renderContainerVariable(
264		VariableAwareInterface $root,
265		$propertyPath = null,
266		VariableAwareInterface $object = null
267		) {
268	328	$variable = $root->getVariable().'_container';
269
270	328	if ($propertyPath !== null) {
271	288	$variable = $this->renderProperty($variable, $propertyPath);
272	144	}
273
274	328	if ($object !== null) {
275	264	$variable = $this->renderProperty($variable, $object->getVariable());
276	132	}
277
278	328	return $variable;
279		}
280
281		/**
282		* @param string $variable
283		* @param string $declaration
284		* @param bool $semicolon
285		* @param bool $newLine
286		*
287		* @return string
288		*/
289	592	public function renderAssignment($variable, $declaration, $semicolon = false, $newLine = false)
290		{
291	592	$separator = $this->renderSeparator();
292
293	592	return $this->renderCode($variable.$separator.'='.$separator.$declaration, $semicolon, $newLine);
294		}
295
296		/**
297		* @param string $statement
298		* @param string $code
299		* @param string\|null $condition
300		* @param string\|null $next
301		* @param bool $newLine
302		*
303		* @return string
304		*/
305	320	public function renderStatement($statement, $code, $condition = null, $next = null, $newLine = true)
306		{
307	320	$separator = $this->renderSeparator();
308	320	$statement .= $separator;
309
310	320	if (!empty($condition)) {
311	312	$statement .= $this->renderArguments([$condition]).$separator;
312	156	}
313
314	320	if (!empty($next)) {
315	292	$next = $separator.$next;
316	146	}
317
318	320	return $this->renderLines([
319	320	$statement.'{',
320	320	$this->renderIndentation($code),
321	320	'}'.$next,
322	320	], true, $newLine);
323		}
324
325		/**
326		* @param string $code
327		* @param bool $semicolon
328		* @param bool $newLine
329		*
330		* @return string
331		*/
332	928	public function renderCode($code, $semicolon = true, $newLine = true)
333		{
334	928	if ($semicolon) {
335	516	$code .= ';';
336	258	}
337
338	928	return $this->renderLine($code, $newLine);
339		}
340
341		/**
342		* @param string\|null $code
343		*
344		* @return string
345		*/
346	584	public function renderIndentation($code = null)
347		{
348	584	if ($this->debug && !empty($code)) {
349	84	$indentation = str_repeat(' ', $this->indentationStep);
350	84	$code = $indentation.str_replace("\n", "\n".$indentation, $code);
351	42	}
352
353	584	return (string) $code;
354		}
355
356		/**
357		* @param string[] $codes
358		* @param bool $newLine
359		* @param bool $eolLine
360		*
361		* @return string
362		*/
363	608	public function renderLines(array $codes, $newLine = true, $eolLine = true)
364		{
365	608	$result = '';
366		$count = count($codes);
367	608
368	600	for ($index = 0; $index < $count; ++$index) {
369	304	$result .= $this->renderLine($codes[$index], $newLine && $index !== $count - 1);
370		}
371	608
372	204	return $this->renderLine($result, $eolLine);
373		}
374
375	600	/**
376	416	* @param string\|null $code
377	536	* @param bool $newLine
378	416	*
379	208	* @return string
380		*/
381	600	public function renderLine($code = null, $newLine = true)
382		{
383		if ($newLine && !empty($code) && $this->debug) {
384		$code .= "\n";
385		}
386
387		return (string) $code;
388		}
389
390	1120	/**
391		* @param string $argument
392	1120	*
393	184	* @return string
394	92	*/
395		public function renderEscape($argument)
396	1120	{
397		return json_encode($argument, JSON_UNESCAPED_SLASHES \| JSON_UNESCAPED_UNICODE);
398		}
399
400		/**
401		* @return string
402		*/
403		public function renderSeparator()
404	544	{
405		return $this->debug ? ' ' : '';
406	544	}
407
408		/**
409		* @param string[] $arguments
410		*
411		* @return string
412	976	*/
413		private function renderArguments(array $arguments)
414	976	{
415		return '('.implode(','.$this->renderSeparator(), $arguments).')';
416		}
417		}
418

egeloen / ivory-google-map

GitHub Access Token became invalid

Pull Request — master (#220)

Formatter B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

24 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like