XmlReferenceDumper::writeNode() - Code Metrics - Inspection of "update config" - iranianpep/geocoder - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 01e071...007090 )

by Ehsan

created 2017-07-02 08:36 UTC

XmlReferenceDumper::writeNode() F

↳ Parent: Project

Complexity

Conditions	45
Paths	> 20000

Size

Total Lines	205
Code Lines	115

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	45
eloc	115
nc	1087104
nop	4
dl	0
loc	205
rs	2
c	0
b	0
f	0

How to fix Long Method Complexity

<?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\Config\Definition\Dumper;

use Symfony\Component\Config\Definition\ConfigurationInterface;
use Symfony\Component\Config\Definition\NodeInterface;
use Symfony\Component\Config\Definition\ArrayNode;
use Symfony\Component\Config\Definition\EnumNode;
use Symfony\Component\Config\Definition\PrototypedArrayNode;

/**
 * Dumps a XML reference configuration for the given configuration/node instance.
 *
 * @author Wouter J <[email protected]>
 */
class XmlReferenceDumper
{
    private $reference;

    public function dump(ConfigurationInterface $configuration, $namespace = null)
    {
        return $this->dumpNode($configuration->getConfigTreeBuilder()->buildTree(), $namespace);
    }

    public function dumpNode(NodeInterface $node, $namespace = null)
    {
        $this->reference = '';
        $this->writeNode($node, 0, true, $namespace);
        $ref = $this->reference;
        $this->reference = null;

        return $ref;
    }

    /**
     * @param NodeInterface $node
     * @param int           $depth
     * @param bool          $root      If the node is the root node
     * @param string        $namespace The namespace of the node
     */
    private function writeNode(NodeInterface $node, $depth = 0, $root = false, $namespace = null)
    {
        $rootName = ($root ? 'config' : $node->getName());
        $rootNamespace = ($namespace ?: ($root ? 'http://example.org/schema/dic/'.$node->getName() : null));

        // xml remapping
        if ($node->getParent()) {
            $remapping = array_filter($node->getParent()->getXmlRemappings(), function ($mapping) use ($rootName) {
                return $rootName === $mapping[1];
            });

            if (count($remapping)) {
                list($singular) = current($remapping);
                $rootName = $singular;
            }
        }
        $rootName = str_replace('_', '-', $rootName);

        $rootAttributes = array();
        $rootAttributeComments = array();
        $rootChildren = array();
        $rootComments = array();

        if ($node instanceof ArrayNode) {
            $children = $node->getChildren();

            // comments about the root node
            if ($rootInfo = $node->getInfo()) {
                $rootComments[] = $rootInfo;
            }

            if ($rootNamespace) {
                $rootComments[] = 'Namespace: '.$rootNamespace;
            }

            // render prototyped nodes
            if ($node instanceof PrototypedArrayNode) {
                $prototype = $node->getPrototype();

                $info = 'prototype';
                if (null !== $prototype->getInfo()) {
                    $info .= ': '.$prototype->getInfo();
                }
                array_unshift($rootComments, $info);

                if ($key = $node->getKeyAttribute()) {
                    $rootAttributes[$key] = str_replace('-', ' ', $rootName).' '.$key;
                }

                if ($prototype instanceof PrototypedArrayNode) {
                    $prototype->setName($key);
                    $children = array($key => $prototype);
                } elseif ($prototype instanceof ArrayNode) {
                    $children = $prototype->getChildren();
                } else {
                    if ($prototype->hasDefaultValue()) {
                        $prototypeValue = $prototype->getDefaultValue();
                    } else {
                        switch (get_class($prototype)) {
                            case 'Symfony\Component\Config\Definition\ScalarNode':
                                $prototypeValue = 'scalar value';
                                break;

                            case 'Symfony\Component\Config\Definition\FloatNode':
                            case 'Symfony\Component\Config\Definition\IntegerNode':
                                $prototypeValue = 'numeric value';
                                break;

                            case 'Symfony\Component\Config\Definition\BooleanNode':
                                $prototypeValue = 'true|false';
                                break;

                            case 'Symfony\Component\Config\Definition\EnumNode':
                                $prototypeValue = implode('|', array_map('json_encode', $prototype->getValues()));
                                break;

                            default:
                                $prototypeValue = 'value';
                        }
                    }
                }
            }

            // get attributes and elements
            foreach ($children as $child) {
                if (!$child instanceof ArrayNode) {
                    // get attributes

                    // metadata
                    $name = str_replace('_', '-', $child->getName());
                    $value = '%%%%not_defined%%%%'; // use a string which isn't used in the normal world

                    // comments
                    $comments = array();
                    if ($info = $child->getInfo()) {
                        $comments[] = $info;
                    }

                    if ($example = $child->getExample()) {
                        $comments[] = 'Example: '.$example;
                    }

                    if ($child->isRequired()) {
                        $comments[] = 'Required';
                    }

                    if ($child instanceof EnumNode) {
                        $comments[] = 'One of '.implode('; ', array_map('json_encode', $child->getValues()));
                    }

                    if (count($comments)) {
                        $rootAttributeComments[$name] = implode(";\n", $comments);
                    }

                    // default values
                    if ($child->hasDefaultValue()) {
                        $value = $child->getDefaultValue();
                    }

                    // append attribute
                    $rootAttributes[$name] = $value;
                } else {
                    // get elements
                    $rootChildren[] = $child;
                }
            }
        }

        // render comments

        // root node comment
        if (count($rootComments)) {
            foreach ($rootComments as $comment) {
                $this->writeLine('<!-- '.$comment.' -->', $depth);
            }
        }

        // attribute comments
        if (count($rootAttributeComments)) {
            foreach ($rootAttributeComments as $attrName => $comment) {
                $commentDepth = $depth + 4 + strlen($attrName) + 2;
                $commentLines = explode("\n", $comment);
                $multiline = (count($commentLines) > 1);
                $comment = implode(PHP_EOL.str_repeat(' ', $commentDepth), $commentLines);

                if ($multiline) {
                    $this->writeLine('<!--', $depth);
                    $this->writeLine($attrName.': '.$comment, $depth + 4);
                    $this->writeLine('-->', $depth);
                } else {
                    $this->writeLine('<!-- '.$attrName.': '.$comment.' -->', $depth);
                }
            }
        }

        // render start tag + attributes
        $rootIsVariablePrototype = isset($prototypeValue);
        $rootIsEmptyTag = (0 === count($rootChildren) && !$rootIsVariablePrototype);
        $rootOpenTag = '<'.$rootName;
        if (1 >= ($attributesCount = count($rootAttributes))) {
            if (1 === $attributesCount) {
                $rootOpenTag .= sprintf(' %s="%s"', current(array_keys($rootAttributes)), $this->writeValue(current($rootAttributes)));
            }

            $rootOpenTag .= $rootIsEmptyTag ? ' />' : '>';

            if ($rootIsVariablePrototype) {
                $rootOpenTag .= $prototypeValue.'</'.$rootName.'>';
            }

            $this->writeLine($rootOpenTag, $depth);
        } else {
            $this->writeLine($rootOpenTag, $depth);

            $i = 1;

            foreach ($rootAttributes as $attrName => $attrValue) {
                $attr = sprintf('%s="%s"', $attrName, $this->writeValue($attrValue));

                $this->writeLine($attr, $depth + 4);

                if ($attributesCount === $i++) {
                    $this->writeLine($rootIsEmptyTag ? '/>' : '>', $depth);

                    if ($rootIsVariablePrototype) {
                        $rootOpenTag .= $prototypeValue.'</'.$rootName.'>';
                    }
                }
            }
        }

        // render children tags
        foreach ($rootChildren as $child) {
            $this->writeLine('');
            $this->writeNode($child, $depth + 4);
        }

        // render end tag
        if (!$rootIsEmptyTag && !$rootIsVariablePrototype) {
            $this->writeLine('');

            $rootEndTag = '</'.$rootName.'>';
            $this->writeLine($rootEndTag, $depth);
        }
    }

    /**
     * Outputs a single config reference line.
     *
     * @param string $text
     * @param int    $indent
     */
    private function writeLine($text, $indent = 0)
    {
        $indent = strlen($text) + $indent;
        $format = '%'.$indent.'s';

        $this->reference .= sprintf($format, $text).PHP_EOL;
    }

    /**
     * Renders the string conversion of the value.
     *
     * @param mixed $value
     *
     * @return string
     */
    private function writeValue($value)
    {
        if ('%%%%not_defined%%%%' === $value) {
            return '';
        }

        if (is_string($value) || is_numeric($value)) {
            return $value;
        }

        if (false === $value) {
            return 'false';
        }

        if (true === $value) {
            return 'true';
        }

        if (null === $value) {
            return 'null';
        }

        if (empty($value)) {
            return '';
        }

        if (is_array($value)) {
            return implode(',', $value);
        }
    }
}


1			<?php
2
3			/*
4			* This file is part of the Symfony package.
5			*
6			* (c) Fabien Potencier <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Symfony\Component\Config\Definition\Dumper;
13
14			use Symfony\Component\Config\Definition\ConfigurationInterface;
15			use Symfony\Component\Config\Definition\NodeInterface;
16			use Symfony\Component\Config\Definition\ArrayNode;
17			use Symfony\Component\Config\Definition\EnumNode;
18			use Symfony\Component\Config\Definition\PrototypedArrayNode;
19
20			/**
21			* Dumps a XML reference configuration for the given configuration/node instance.
22			*
23			* @author Wouter J <[email protected]>
24			*/
25			class XmlReferenceDumper
26			{
27			private $reference;
28
29			public function dump(ConfigurationInterface $configuration, $namespace = null)
30			{
31			return $this->dumpNode($configuration->getConfigTreeBuilder()->buildTree(), $namespace);
32			}
33
34			public function dumpNode(NodeInterface $node, $namespace = null)
35			{
36			$this->reference = '';
37			$this->writeNode($node, 0, true, $namespace);
38			$ref = $this->reference;
39			$this->reference = null;
40
41			return $ref;
42			}
43
44			/**
45			* @param NodeInterface $node
46			* @param int $depth
47			* @param bool $root If the node is the root node
48			* @param string $namespace The namespace of the node
49			*/
50			private function writeNode(NodeInterface $node, $depth = 0, $root = false, $namespace = null)
51			{
52			$rootName = ($root ? 'config' : $node->getName());
53			$rootNamespace = ($namespace ?: ($root ? 'http://example.org/schema/dic/'.$node->getName() : null));
54
55			// xml remapping
56			if ($node->getParent()) {
57			$remapping = array_filter($node->getParent()->getXmlRemappings(), function ($mapping) use ($rootName) {
58			return $rootName === $mapping[1];
59			});
60
61			if (count($remapping)) {
62			list($singular) = current($remapping);
63			$rootName = $singular;
64			}
65			}
66			$rootName = str_replace('_', '-', $rootName);
67
68			$rootAttributes = array();
69			$rootAttributeComments = array();
70			$rootChildren = array();
71			$rootComments = array();
72
73			if ($node instanceof ArrayNode) {
74			$children = $node->getChildren();
75
76			// comments about the root node
77			if ($rootInfo = $node->getInfo()) {
78			$rootComments[] = $rootInfo;
79			}
80
81			if ($rootNamespace) {
82			$rootComments[] = 'Namespace: '.$rootNamespace;
83			}
84
85			// render prototyped nodes
86			if ($node instanceof PrototypedArrayNode) {
87			$prototype = $node->getPrototype();
88
89			$info = 'prototype';
90			if (null !== $prototype->getInfo()) {
91			$info .= ': '.$prototype->getInfo();
92			}
93			array_unshift($rootComments, $info);
94
95			if ($key = $node->getKeyAttribute()) {
96			$rootAttributes[$key] = str_replace('-', ' ', $rootName).' '.$key;
97			}
98
99			if ($prototype instanceof PrototypedArrayNode) {
100			$prototype->setName($key);
101			$children = array($key => $prototype);
102			} elseif ($prototype instanceof ArrayNode) {
103			$children = $prototype->getChildren();
104			} else {
105			if ($prototype->hasDefaultValue()) {
106			$prototypeValue = $prototype->getDefaultValue();
107			} else {
108			switch (get_class($prototype)) {
109			case 'Symfony\Component\Config\Definition\ScalarNode':
110			$prototypeValue = 'scalar value';
111			break;
112
113			case 'Symfony\Component\Config\Definition\FloatNode':
114			case 'Symfony\Component\Config\Definition\IntegerNode':
115			$prototypeValue = 'numeric value';
116			break;
117
118			case 'Symfony\Component\Config\Definition\BooleanNode':
119			$prototypeValue = 'true\|false';
120			break;
121
122			case 'Symfony\Component\Config\Definition\EnumNode':
123			$prototypeValue = implode('\|', array_map('json_encode', $prototype->getValues()));
124			break;
125
126			default:
127			$prototypeValue = 'value';
128			}
129			}
130			}
131			}
132
133			// get attributes and elements
134			foreach ($children as $child) {
135			if (!$child instanceof ArrayNode) {
136			// get attributes
137
138			// metadata
139			$name = str_replace('_', '-', $child->getName());
140			$value = '%%%%not_defined%%%%'; // use a string which isn't used in the normal world
141
142			// comments
143			$comments = array();
144			if ($info = $child->getInfo()) {
145			$comments[] = $info;
146			}
147
148			if ($example = $child->getExample()) {
149			$comments[] = 'Example: '.$example;
150			}
151
152			if ($child->isRequired()) {
153			$comments[] = 'Required';
154			}
155
156			if ($child instanceof EnumNode) {
157			$comments[] = 'One of '.implode('; ', array_map('json_encode', $child->getValues()));
158			}
159
160			if (count($comments)) {
161			$rootAttributeComments[$name] = implode(";\n", $comments);
162			}
163
164			// default values
165			if ($child->hasDefaultValue()) {
166			$value = $child->getDefaultValue();
167			}
168
169			// append attribute
170			$rootAttributes[$name] = $value;
171			} else {
172			// get elements
173			$rootChildren[] = $child;
174			}
175			}
176			}
177
178			// render comments
179
180			// root node comment
181			if (count($rootComments)) {
182			foreach ($rootComments as $comment) {
183			$this->writeLine('<!-- '.$comment.' -->', $depth);
184			}
185			}
186
187			// attribute comments
188			if (count($rootAttributeComments)) {
189			foreach ($rootAttributeComments as $attrName => $comment) {
190			$commentDepth = $depth + 4 + strlen($attrName) + 2;
191			$commentLines = explode("\n", $comment);
192			$multiline = (count($commentLines) > 1);
193			$comment = implode(PHP_EOL.str_repeat(' ', $commentDepth), $commentLines);
194
195			if ($multiline) {
196			$this->writeLine('<!--', $depth);
197			$this->writeLine($attrName.': '.$comment, $depth + 4);
198			$this->writeLine('-->', $depth);
199			} else {
200			$this->writeLine('<!-- '.$attrName.': '.$comment.' -->', $depth);
201			}
202			}
203			}
204
205			// render start tag + attributes
206			$rootIsVariablePrototype = isset($prototypeValue);
207			$rootIsEmptyTag = (0 === count($rootChildren) && !$rootIsVariablePrototype);
208			$rootOpenTag = '<'.$rootName;
209			if (1 >= ($attributesCount = count($rootAttributes))) {
210			if (1 === $attributesCount) {
211			$rootOpenTag .= sprintf(' %s="%s"', current(array_keys($rootAttributes)), $this->writeValue(current($rootAttributes)));
212			}
213
214			$rootOpenTag .= $rootIsEmptyTag ? ' />' : '>';
215
216			if ($rootIsVariablePrototype) {
217			$rootOpenTag .= $prototypeValue.'</'.$rootName.'>';
218			}
219
220			$this->writeLine($rootOpenTag, $depth);
221			} else {
222			$this->writeLine($rootOpenTag, $depth);
223
224			$i = 1;
225
226			foreach ($rootAttributes as $attrName => $attrValue) {
227			$attr = sprintf('%s="%s"', $attrName, $this->writeValue($attrValue));
228
229			$this->writeLine($attr, $depth + 4);
230
231			if ($attributesCount === $i++) {
232			$this->writeLine($rootIsEmptyTag ? '/>' : '>', $depth);
233
234			if ($rootIsVariablePrototype) {
235			$rootOpenTag .= $prototypeValue.'</'.$rootName.'>';
236			}
237			}
238			}
239			}
240
241			// render children tags
242			foreach ($rootChildren as $child) {
243			$this->writeLine('');
244			$this->writeNode($child, $depth + 4);
245			}
246
247			// render end tag
248			if (!$rootIsEmptyTag && !$rootIsVariablePrototype) {
249			$this->writeLine('');
250
251			$rootEndTag = '</'.$rootName.'>';
252			$this->writeLine($rootEndTag, $depth);
253			}
254			}
255
256			/**
257			* Outputs a single config reference line.
258			*
259			* @param string $text
260			* @param int $indent
261			*/
262			private function writeLine($text, $indent = 0)
263			{
264			$indent = strlen($text) + $indent;
265			$format = '%'.$indent.'s';
266
267			$this->reference .= sprintf($format, $text).PHP_EOL;
268			}
269
270			/**
271			* Renders the string conversion of the value.
272			*
273			* @param mixed $value
274			*
275			* @return string
276			*/
277			private function writeValue($value)
278			{
279			if ('%%%%not_defined%%%%' === $value) {
280			return '';
281			}
282
283			if (is_string($value) \|\| is_numeric($value)) {
284			return $value;
285			}
286
287			if (false === $value) {
288			return 'false';
289			}
290
291			if (true === $value) {
292			return 'true';
293			}
294
295			if (null === $value) {
296			return 'null';
297			}
298
299			if (empty($value)) {
300			return '';
301			}
302
303			if (is_array($value)) {
304			return implode(',', $value);
305			}
306			}
307			}
308

iranianpep / geocoder

Push — master ( 01e071...007090 )

XmlReferenceDumper::writeNode() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like