Version2::buildIgnoreSymlinks() - Code Metrics - Inspection of "Fix style and stan issues" - phpDocumentor/phpDocumentor - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 373768...b82813 )

by Mike

created 2019-06-15 19:04 UTC

Version2::buildIgnoreSymlinks() A

↳ Parent: Version2

Complexity

Conditions	3
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	3.0416

Importance

Changes

Metric	Value
cc	3
nc	3
nop	1
dl	0
loc	12
ccs	5
cts	6
cp	0.8333
crap	3.0416
rs	9.8666
c	0
b	0
f	0

<?php
declare(strict_types=1);

/**
 * This file is part of phpDocumentor.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * @author    Mike van Riel <[email protected]>
 * @copyright 2010-2018 Mike van Riel / Naenius (http://www.naenius.com)
 * @license   http://www.opensource.org/licenses/mit-license.php MIT
 * @link      http://phpdoc.org
 */

namespace phpDocumentor\Configuration\Factory;

use InvalidArgumentException;
use phpDocumentor\Dsn;
use phpDocumentor\Path;
use SimpleXMLElement;

/**
 * phpDocumentor2 strategy for converting the configuration xml to an array.
 */
final class Version2 implements Strategy
{
    /** @var string[] */
    private $extensions = ['php', 'php3', 'phtml'];

    /** @var string[] */
    private $markers = ['TODO', 'FIXME'];

    /** @var string[] */
    private $visibility = ['public', 'protected', 'private'];

    /** @var string */
    private $defaultPackageName = 'Default';

    /** @var string */
    private $template = 'clean';

    /** @var bool */
    private $ignoreHidden = true;

    /** @var bool */
    private $ignoreSymlinks = true;

    /** @var string[] */
    private $ignorePaths = [];

    /** @var string */
    private $outputDirectory = 'file://build/docs';

    /** @var string[] */
    private $directories = ['src'];

    private $includeSource = false;

    public function convert(SimpleXMLElement $phpDocumentor): array
    {
        $this->validate($phpDocumentor);

        $outputDirectory = $this->buildOutputDirectory($phpDocumentor);

        return [
            'phpdocumentor' => [
                'title' => ((string)$phpDocumentor->title) ?: 'my-doc',
                'use-cache' => true,
                'paths' => [
                    'output' => new Dsn($outputDirectory),
                    'cache' => new Path('/tmp/phpdoc-doc-cache'),
                ],
                'versions' => [
                    '1.0.0' => [
                        'folder' => '',
                        'api' => [
                            0 => [
                                'encoding' => 'utf8',
                                'ignore-tags' => [],
                                'format' => 'php',
                                'validate' => false,
                                'source' => [
                                    'dsn' => new Dsn('file://' . getcwd()),
                                    'paths' => $this->buildSourcePaths($phpDocumentor),
                                ],
                                'ignore' => [
                                    'hidden' => $this->buildIgnoreHidden($phpDocumentor),
                                    'symlinks' => $this->buildIgnoreSymlinks($phpDocumentor),
                                    'paths' => $this->buildIgnorePaths($phpDocumentor),
                                ],
                                'extensions' => $this->buildExtensions($phpDocumentor),
                                'visibility' => $this->buildVisibility($phpDocumentor),
                                'include-source' => $this->buildIncludeSourcecode($phpDocumentor),
                                'default-package-name' => $this->buildDefaultPackageName($phpDocumentor),
                                'markers' => $this->buildMarkers($phpDocumentor),
                            ],
                        ],
                    ],
                ],
                'templates' => [
                    [
                        'name' => $this->buildTemplate($phpDocumentor),
                    ],
                ],
            ],
        ];
    }

    public function supports(SimpleXMLElement $phpDocumentor): bool
    {
        return isset($phpDocumentor->attributes()->version) === false
            || $phpDocumentor->attributes()->version == '2';
    }

    /**
     * Loops over a node and fills an array with the found children.
     */
    private function buildArrayFromNode(SimpleXMLElement $node): array
    {
        $array = [];
        foreach ($node->children() as $child) {
            if ((string) $child !== '') {
                $array[] = (string) $child;
            }
        }

        return $array;
    }

    /**
     * Builds the extensions part of the array from the configuration xml.
     *
     * @return string[]
     */
    private function buildExtensions(SimpleXMLElement $phpDocumentor): array
    {
        if ((array) $phpDocumentor->parser === []) {
            return $this->extensions;
        }

        if ((array) $phpDocumentor->parser->extensions === []) {
            return $this->extensions;
        }

        return $this->buildArrayFromNode($phpDocumentor->parser->extensions);
    }

    /**
     * Builds the markers part of the array from the configuration xml.
     *
     * @return string[]
     */
    private function buildMarkers(SimpleXMLElement $phpDocumentor): array
    {
        if ((array) $phpDocumentor->parser === []) {
            return $this->markers;
        }

        if ((array) $phpDocumentor->parser->markers === []) {
            return $this->markers;
        }

        return $this->buildArrayFromNode($phpDocumentor->parser->markers);
    }

    /**
     * Builds whether the source code should be part of the output.
     */
    private function buildIncludeSourcecode(SimpleXMLElement $phpDocumentor): bool
    {
        if ((array) $phpDocumentor->parser === []) {
            return $this->includeSource;
        }

        return (bool) $phpDocumentor->parser->{'include-source'};
    }

    /**
     * Builds the visibility part of the array from the configuration xml.
     *
     * @return string[]
     */
    private function buildVisibility(SimpleXMLElement $phpDocumentor): array
    {
        if ((array) $phpDocumentor->parser === []) {
            return $this->visibility;
        }

        if ((string) $phpDocumentor->parser->visibility === '') {
            return $this->visibility;
        }

        return explode(',', (string) $phpDocumentor->parser->visibility);
    }

    /**
     * Builds the defaultPackageName part of the array from the configuration xml.
     */
    private function buildDefaultPackageName(SimpleXMLElement $phpDocumentor): string
    {
        if ((array) $phpDocumentor->parser === []) {
            return $this->defaultPackageName;
        }

        if ((string) $phpDocumentor->parser->{'default-package-name'} === '') {
            return $this->defaultPackageName;
        }

        return (string) $phpDocumentor->parser->{'default-package-name'};
    }

    /**
     * Builds the template part of the array from the configuration xml.
     */
    private function buildTemplate(SimpleXMLElement $phpDocumentor): string
    {
        if ((array) $phpDocumentor->transformations === []) {
            return $this->template;
        }

        if ((string) $phpDocumentor->transformations->template === '') {
            return $this->template;
        }

        return (string) $phpDocumentor->transformations->template->attributes()->name;
    }

    /**
     * Builds the ignore-hidden part of the array from the configuration xml.
     */
    private function buildIgnoreHidden(SimpleXMLElement $phpDocumentor): bool
    {
        if ((array) $phpDocumentor->files === []) {
            return $this->ignoreHidden;
        }

        if ((string) $phpDocumentor->files->{'ignore-hidden'} === '') {
            return $this->ignoreHidden;
        }

        return filter_var($phpDocumentor->files->{'ignore-hidden'}, FILTER_VALIDATE_BOOLEAN);
    }

    /**
     * Builds the ignore-symlinks part of the array from the configuration xml.
     */
    private function buildIgnoreSymlinks(SimpleXMLElement $phpDocumentor): bool
    {
        if ((array) $phpDocumentor->files === []) {
            return $this->ignoreSymlinks;
        }

        if ((string) $phpDocumentor->files->{'ignore-symlinks'} === '') {
            return $this->ignoreSymlinks;
        }

        return filter_var($phpDocumentor->files->{'ignore-symlinks'}, FILTER_VALIDATE_BOOLEAN);
    }

    /**
     * Builds the ignorePaths part of the array from the configuration xml.
     *
     * @return string[]
     */
    private function buildIgnorePaths(SimpleXMLElement $phpDocumentor): array
    {
        if ((array) $phpDocumentor->files === []) {
            return $this->ignorePaths;
        }
        $ignorePaths = [];
        foreach ($phpDocumentor->files->children() as $child) {
            if ($child->getName() === 'ignore') {
                $ignorePaths[] = (string) $child;
            }
        }

        if (count($ignorePaths) === 0) {
            return $this->ignorePaths;
        }

        return $ignorePaths;
    }

    /**
     * Builds the outputDirectory part of the array from the configuration xml.
     */
    private function buildOutputDirectory(SimpleXMLElement $phpDocumentor): string
    {
        if ((array) $phpDocumentor->transformer === []) {
            return $this->outputDirectory;
        }

        if ((string) $phpDocumentor->transformer->target === '') {
            return $this->outputDirectory;
        }

        return (string) $phpDocumentor->transformer->target;
    }

    /**
     * Builds the directories that are used in the sourcePaths.
     *
     * @return string[]
     */
    private function buildDirectories(SimpleXMLElement $phpDocumentor): array
    {
        if ((array) $phpDocumentor->files === []) {
            return $this->directories;
        }

        if ((string) $phpDocumentor->files->directory === '') {
            return $this->directories;
        }

        return (array) $phpDocumentor->files->directory;
    }

    /**
     * Builds the sourcePaths part of the array from the configuration xml.
     *
     * @return Path[]
     */
    private function buildSourcePaths(SimpleXMLElement $phpDocumentor): array
    {
        $sourcePaths = [];
        $directories = $this->buildDirectories($phpDocumentor);

        foreach ($directories as $directory) {
            $sourcePaths[] = (new Dsn($directory))->getPath();
        }

        return $sourcePaths;
    }

    /**
     * Validates if the xml has a root element which name is phpdocumentor.
     *
     * @throws InvalidArgumentException if the root element of the xml is not phpdocumentor.
     */
    private function validate(SimpleXMLElement $xml): void
    {
        if ($xml->getName() !== 'phpdocumentor') {
            throw new InvalidArgumentException(
                sprintf('Root element name should be phpdocumentor, %s found', $xml->getName())
            );
        }
    }
}


1		<?php
2		declare(strict_types=1);
3
4		/**
5		* This file is part of phpDocumentor.
6		*
7		* For the full copyright and license information, please view the LICENSE
8		* file that was distributed with this source code.
9		*
10		* @author Mike van Riel <[email protected]>
11		* @copyright 2010-2018 Mike van Riel / Naenius (http://www.naenius.com)
12		* @license http://www.opensource.org/licenses/mit-license.php MIT
13		* @link http://phpdoc.org
14		*/
15
16		namespace phpDocumentor\Configuration\Factory;
17
18		use InvalidArgumentException;
19		use phpDocumentor\Dsn;
20		use phpDocumentor\Path;
21		use SimpleXMLElement;
22
23		/**
24		* phpDocumentor2 strategy for converting the configuration xml to an array.
25		*/
26		final class Version2 implements Strategy
27		{
28		/** @var string[] */
29		private $extensions = ['php', 'php3', 'phtml'];
30
31		/** @var string[] */
32		private $markers = ['TODO', 'FIXME'];
33
34		/** @var string[] */
35		private $visibility = ['public', 'protected', 'private'];
36
37		/** @var string */
38		private $defaultPackageName = 'Default';
39
40		/** @var string */
41		private $template = 'clean';
42
43		/** @var bool */
44		private $ignoreHidden = true;
45
46		/** @var bool */
47		private $ignoreSymlinks = true;
48
49		/** @var string[] */
50		private $ignorePaths = [];
51
52		/** @var string */
53		private $outputDirectory = 'file://build/docs';
54
55		/** @var string[] */
56		private $directories = ['src'];
57
58		private $includeSource = false;
59
60	5	public function convert(SimpleXMLElement $phpDocumentor): array
61		{
62	5	$this->validate($phpDocumentor);
63
64	5	$outputDirectory = $this->buildOutputDirectory($phpDocumentor);
65
66		return [
67	5	'phpdocumentor' => [
68	5	'title' => ((string)$phpDocumentor->title) ?: 'my-doc',
69		'use-cache' => true,
70		'paths' => [
71	5	'output' => new Dsn($outputDirectory),
72	5	'cache' => new Path('/tmp/phpdoc-doc-cache'),
73		],
74		'versions' => [
75		'1.0.0' => [
76	5	'folder' => '',
77		'api' => [
78		0 => [
79	5	'encoding' => 'utf8',
80		'ignore-tags' => [],
81	5	'format' => 'php',
82		'validate' => false,
83		'source' => [
84	5	'dsn' => new Dsn('file://' . getcwd()),
85	5	'paths' => $this->buildSourcePaths($phpDocumentor),
86		],
87		'ignore' => [
88	5	'hidden' => $this->buildIgnoreHidden($phpDocumentor),
89	5	'symlinks' => $this->buildIgnoreSymlinks($phpDocumentor),
90	5	'paths' => $this->buildIgnorePaths($phpDocumentor),
91		],
92	5	'extensions' => $this->buildExtensions($phpDocumentor),
93	5	'visibility' => $this->buildVisibility($phpDocumentor),
94	5	'include-source' => $this->buildIncludeSourcecode($phpDocumentor),
95	5	'default-package-name' => $this->buildDefaultPackageName($phpDocumentor),
96	5	'markers' => $this->buildMarkers($phpDocumentor),
97		],
98		],
99		],
100		],
101		'templates' => [
102		[
103	5	'name' => $this->buildTemplate($phpDocumentor),
104		],
105		],
106		],
107		];
108		}
109
110	1	public function supports(SimpleXMLElement $phpDocumentor): bool
111		{
112	1	return isset($phpDocumentor->attributes()->version) === false
113	1	\|\| $phpDocumentor->attributes()->version == '2';
114		}
115
116		/**
117		* Loops over a node and fills an array with the found children.
118		*/
119	1	private function buildArrayFromNode(SimpleXMLElement $node): array
120		{
121	1	$array = [];
122	1	foreach ($node->children() as $child) {
123	1	if ((string) $child !== '') {
124	1	$array[] = (string) $child;
125		}
126		}
127
128	1	return $array;
129		}
130
131		/**
132		* Builds the extensions part of the array from the configuration xml.
133		*
134		* @return string[]
135		*/
136	5	private function buildExtensions(SimpleXMLElement $phpDocumentor): array
137		{
138	5	if ((array) $phpDocumentor->parser === []) {
139		return $this->extensions;
140		}
141
142	5	if ((array) $phpDocumentor->parser->extensions === []) {
143	4	return $this->extensions;
144		}
145
146	1	return $this->buildArrayFromNode($phpDocumentor->parser->extensions);
147		}
148
149		/**
150		* Builds the markers part of the array from the configuration xml.
151		*
152		* @return string[]
153		*/
154	5	private function buildMarkers(SimpleXMLElement $phpDocumentor): array
155		{
156	5	if ((array) $phpDocumentor->parser === []) {
157		return $this->markers;
158		}
159
160	5	if ((array) $phpDocumentor->parser->markers === []) {
161	4	return $this->markers;
162		}
163
164	1	return $this->buildArrayFromNode($phpDocumentor->parser->markers);
165		}
166
167		/**
168		* Builds whether the source code should be part of the output.
169		*/
170	5	private function buildIncludeSourcecode(SimpleXMLElement $phpDocumentor): bool
171		{
172	5	if ((array) $phpDocumentor->parser === []) {
173		return $this->includeSource;
174		}
175
176	5	return (bool) $phpDocumentor->parser->{'include-source'};
177		}
178
179		/**
180		* Builds the visibility part of the array from the configuration xml.
181		*
182		* @return string[]
183		*/
184	5	private function buildVisibility(SimpleXMLElement $phpDocumentor): array
185		{
186	5	if ((array) $phpDocumentor->parser === []) {
187		return $this->visibility;
188		}
189
190	5	if ((string) $phpDocumentor->parser->visibility === '') {
191	4	return $this->visibility;
192		}
193
194	1	return explode(',', (string) $phpDocumentor->parser->visibility);
195		}
196
197		/**
198		* Builds the defaultPackageName part of the array from the configuration xml.
199		*/
200	5	private function buildDefaultPackageName(SimpleXMLElement $phpDocumentor): string
201		{
202	5	if ((array) $phpDocumentor->parser === []) {
203		return $this->defaultPackageName;
204		}
205
206	5	if ((string) $phpDocumentor->parser->{'default-package-name'} === '') {
207		return $this->defaultPackageName;
208		}
209
210	5	return (string) $phpDocumentor->parser->{'default-package-name'};
211		}
212
213		/**
214		* Builds the template part of the array from the configuration xml.
215		*/
216	5	private function buildTemplate(SimpleXMLElement $phpDocumentor): string
217		{
218	5	if ((array) $phpDocumentor->transformations === []) {
219		return $this->template;
220		}
221
222	5	if ((string) $phpDocumentor->transformations->template === '') {
223	5	return $this->template;
224		}
225
226		return (string) $phpDocumentor->transformations->template->attributes()->name;
227		}
228
229		/**
230		* Builds the ignore-hidden part of the array from the configuration xml.
231		*/
232	5	private function buildIgnoreHidden(SimpleXMLElement $phpDocumentor): bool
233		{
234	5	if ((array) $phpDocumentor->files === []) {
235		return $this->ignoreHidden;
236		}
237
238	5	if ((string) $phpDocumentor->files->{'ignore-hidden'} === '') {
239	4	return $this->ignoreHidden;
240		}
241
242	1	return filter_var($phpDocumentor->files->{'ignore-hidden'}, FILTER_VALIDATE_BOOLEAN);
243		}
244
245		/**
246		* Builds the ignore-symlinks part of the array from the configuration xml.
247		*/
248	5	private function buildIgnoreSymlinks(SimpleXMLElement $phpDocumentor): bool
249		{
250	5	if ((array) $phpDocumentor->files === []) {
251		return $this->ignoreSymlinks;
252		}
253
254	5	if ((string) $phpDocumentor->files->{'ignore-symlinks'} === '') {
255	4	return $this->ignoreSymlinks;
256		}
257
258	1	return filter_var($phpDocumentor->files->{'ignore-symlinks'}, FILTER_VALIDATE_BOOLEAN);
259		}
260
261		/**
262		* Builds the ignorePaths part of the array from the configuration xml.
263		*
264		* @return string[]
265		*/
266	5	private function buildIgnorePaths(SimpleXMLElement $phpDocumentor): array
267		{
268	5	if ((array) $phpDocumentor->files === []) {
269		return $this->ignorePaths;
270		}
271	5	$ignorePaths = [];
272	5	foreach ($phpDocumentor->files->children() as $child) {
273	5	if ($child->getName() === 'ignore') {
274	5	$ignorePaths[] = (string) $child;
275		}
276		}
277
278	5	if (count($ignorePaths) === 0) {
279	4	return $this->ignorePaths;
280		}
281
282	1	return $ignorePaths;
283		}
284
285		/**
286		* Builds the outputDirectory part of the array from the configuration xml.
287		*/
288	5	private function buildOutputDirectory(SimpleXMLElement $phpDocumentor): string
289		{
290	5	if ((array) $phpDocumentor->transformer === []) {
291		return $this->outputDirectory;
292		}
293
294	5	if ((string) $phpDocumentor->transformer->target === '') {
295		return $this->outputDirectory;
296		}
297
298	5	return (string) $phpDocumentor->transformer->target;
299		}
300
301		/**
302		* Builds the directories that are used in the sourcePaths.
303		*
304		* @return string[]
305		*/
306	5	private function buildDirectories(SimpleXMLElement $phpDocumentor): array
307		{
308	5	if ((array) $phpDocumentor->files === []) {
309		return $this->directories;
310		}
311
312	5	if ((string) $phpDocumentor->files->directory === '') {
313		return $this->directories;
314		}
315
316	5	return (array) $phpDocumentor->files->directory;
317		}
318
319		/**
320		* Builds the sourcePaths part of the array from the configuration xml.
321		*
322		* @return Path[]
323		*/
324	5	private function buildSourcePaths(SimpleXMLElement $phpDocumentor): array
325		{
326	5	$sourcePaths = [];
327	5	$directories = $this->buildDirectories($phpDocumentor);
328
329	5	foreach ($directories as $directory) {
330	5	$sourcePaths[] = (new Dsn($directory))->getPath();
331		}
332
333	5	return $sourcePaths;
334		}
335
336		/**
337		* Validates if the xml has a root element which name is phpdocumentor.
338		*
339		* @throws InvalidArgumentException if the root element of the xml is not phpdocumentor.
340		*/
341	6	private function validate(SimpleXMLElement $xml): void
342		{
343	6	if ($xml->getName() !== 'phpdocumentor') {
344	1	throw new InvalidArgumentException(
345	1	sprintf('Root element name should be phpdocumentor, %s found', $xml->getName())
346		);
347		}
348	5	}
349		}
350

phpDocumentor / phpDocumentor

Push — develop ( 373768...b82813 )

Version2::buildIgnoreSymlinks() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like