Version2::buildIgnoreHidden() - Code Metrics - phpDocumentor/phpDocumentor - Measure and Improve Code Quality continuously with Scrutinizer

Version2::buildIgnoreHidden() A
last analyzed 2019-11-23 16:53 UTC

↳ 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);
        $cacheDirectory = $this->buildCacheDirectory($phpDocumentor);

        return [
            'phpdocumentor' => [
                'title' => ((string)$phpDocumentor->title) ?: 'my-doc',
                'use-cache' => true,
                'paths' => [
                    'output' => new Dsn($outputDirectory),
                    'cache' => new Path($cacheDirectory),
                ],
                'versions' => [
                    '1.0.0' => [
                        'folder' => '',
                        'api' => [
                            0 => [
                                'encoding' => $this->buildEncoding($phpDocumentor),
                                '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;
    }

    /**
     * Builds the outputDirectory part of the array from the configuration xml.
     */
    private function buildCacheDirectory(SimpleXMLElement $phpDocumentor): string
    {
        if ((array) $phpDocumentor->parser === []) {
            return '/tmp/phpdoc-doc-cache';
        }

        if ((string) $phpDocumentor->parser->target === '') {
            return '/tmp/phpdoc-doc-cache';
        }

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

    /**
     * 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())
            );
        }
    }

    private function buildEncoding(SimpleXMLElement $phpDocumentor)
    {
        if ((array) $phpDocumentor->parser === []) {
            return 'utf-8';
        }

        if ((string) $phpDocumentor->parser->encoding === '') {
            return 'utf-8';
        }

        return (string) $phpDocumentor->parser->encoding;
    }
}


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	6	public function convert(SimpleXMLElement $phpDocumentor): array
61		{
62	6	$this->validate($phpDocumentor);
63
64	6	$outputDirectory = $this->buildOutputDirectory($phpDocumentor);
65	6	$cacheDirectory = $this->buildCacheDirectory($phpDocumentor);
66
67		return [
68	6	'phpdocumentor' => [
69	6	'title' => ((string)$phpDocumentor->title) ?: 'my-doc',
70		'use-cache' => true,
71		'paths' => [
72	6	'output' => new Dsn($outputDirectory),
73	6	'cache' => new Path($cacheDirectory),
74		],
75		'versions' => [
76		'1.0.0' => [
77	6	'folder' => '',
78		'api' => [
79		0 => [
80	6	'encoding' => $this->buildEncoding($phpDocumentor),
81		'ignore-tags' => [],
82	6	'format' => 'php',
83		'validate' => false,
84		'source' => [
85	6	'dsn' => new Dsn('file://' . getcwd()),
86	6	'paths' => $this->buildSourcePaths($phpDocumentor),
87		],
88		'ignore' => [
89	6	'hidden' => $this->buildIgnoreHidden($phpDocumentor),
90	6	'symlinks' => $this->buildIgnoreSymlinks($phpDocumentor),
91	6	'paths' => $this->buildIgnorePaths($phpDocumentor),
92		],
93	6	'extensions' => $this->buildExtensions($phpDocumentor),
94	6	'visibility' => $this->buildVisibility($phpDocumentor),
95	6	'include-source' => $this->buildIncludeSourcecode($phpDocumentor),
96	6	'default-package-name' => $this->buildDefaultPackageName($phpDocumentor),
97	6	'markers' => $this->buildMarkers($phpDocumentor),
98		],
99		],
100		],
101		],
102		'templates' => [
103		[
104	6	'name' => $this->buildTemplate($phpDocumentor),
105		],
106		],
107		],
108		];
109		}
110
111	1	public function supports(SimpleXMLElement $phpDocumentor): bool
112		{
113	1	return isset($phpDocumentor->attributes()->version) === false
114	1	\|\| $phpDocumentor->attributes()->version == '2';
115		}
116
117		/**
118		* Loops over a node and fills an array with the found children.
119		*/
120	1	private function buildArrayFromNode(SimpleXMLElement $node): array
121		{
122	1	$array = [];
123	1	foreach ($node->children() as $child) {
124	1	if ((string) $child !== '') {
125	1	$array[] = (string) $child;
126		}
127		}
128
129	1	return $array;
130		}
131
132		/**
133		* Builds the extensions part of the array from the configuration xml.
134		*
135		* @return string[]
136		*/
137	6	private function buildExtensions(SimpleXMLElement $phpDocumentor): array
138		{
139	6	if ((array) $phpDocumentor->parser === []) {
140		return $this->extensions;
141		}
142
143	6	if ((array) $phpDocumentor->parser->extensions === []) {
144	5	return $this->extensions;
145		}
146
147	1	return $this->buildArrayFromNode($phpDocumentor->parser->extensions);
148		}
149
150		/**
151		* Builds the markers part of the array from the configuration xml.
152		*
153		* @return string[]
154		*/
155	6	private function buildMarkers(SimpleXMLElement $phpDocumentor): array
156		{
157	6	if ((array) $phpDocumentor->parser === []) {
158		return $this->markers;
159		}
160
161	6	if ((array) $phpDocumentor->parser->markers === []) {
162	5	return $this->markers;
163		}
164
165	1	return $this->buildArrayFromNode($phpDocumentor->parser->markers);
166		}
167
168		/**
169		* Builds whether the source code should be part of the output.
170		*/
171	6	private function buildIncludeSourcecode(SimpleXMLElement $phpDocumentor): bool
172		{
173	6	if ((array) $phpDocumentor->parser === []) {
174		return $this->includeSource;
175		}
176
177	6	return (bool) $phpDocumentor->parser->{'include-source'};
178		}
179
180		/**
181		* Builds the visibility part of the array from the configuration xml.
182		*
183		* @return string[]
184		*/
185	6	private function buildVisibility(SimpleXMLElement $phpDocumentor): array
186		{
187	6	if ((array) $phpDocumentor->parser === []) {
188		return $this->visibility;
189		}
190
191	6	if ((string) $phpDocumentor->parser->visibility === '') {
192	5	return $this->visibility;
193		}
194
195	1	return explode(',', (string) $phpDocumentor->parser->visibility);
196		}
197
198		/**
199		* Builds the defaultPackageName part of the array from the configuration xml.
200		*/
201	6	private function buildDefaultPackageName(SimpleXMLElement $phpDocumentor): string
202		{
203	6	if ((array) $phpDocumentor->parser === []) {
204		return $this->defaultPackageName;
205		}
206
207	6	if ((string) $phpDocumentor->parser->{'default-package-name'} === '') {
208		return $this->defaultPackageName;
209		}
210
211	6	return (string) $phpDocumentor->parser->{'default-package-name'};
212		}
213
214		/**
215		* Builds the template part of the array from the configuration xml.
216		*/
217	6	private function buildTemplate(SimpleXMLElement $phpDocumentor): string
218		{
219	6	if ((array) $phpDocumentor->transformations === []) {
220		return $this->template;
221		}
222
223	6	if ((string) $phpDocumentor->transformations->template === '') {
224	6	return $this->template;
225		}
226
227		return (string) $phpDocumentor->transformations->template->attributes()->name;
228		}
229
230		/**
231		* Builds the ignore-hidden part of the array from the configuration xml.
232		*/
233	6	private function buildIgnoreHidden(SimpleXMLElement $phpDocumentor): bool
234		{
235	6	if ((array) $phpDocumentor->files === []) {
236		return $this->ignoreHidden;
237		}
238
239	6	if ((string) $phpDocumentor->files->{'ignore-hidden'} === '') {
240	5	return $this->ignoreHidden;
241		}
242
243	1	return filter_var($phpDocumentor->files->{'ignore-hidden'}, FILTER_VALIDATE_BOOLEAN);
244		}
245
246		/**
247		* Builds the ignore-symlinks part of the array from the configuration xml.
248		*/
249	6	private function buildIgnoreSymlinks(SimpleXMLElement $phpDocumentor): bool
250		{
251	6	if ((array) $phpDocumentor->files === []) {
252		return $this->ignoreSymlinks;
253		}
254
255	6	if ((string) $phpDocumentor->files->{'ignore-symlinks'} === '') {
256	5	return $this->ignoreSymlinks;
257		}
258
259	1	return filter_var($phpDocumentor->files->{'ignore-symlinks'}, FILTER_VALIDATE_BOOLEAN);
260		}
261
262		/**
263		* Builds the ignorePaths part of the array from the configuration xml.
264		*
265		* @return string[]
266		*/
267	6	private function buildIgnorePaths(SimpleXMLElement $phpDocumentor): array
268		{
269	6	if ((array) $phpDocumentor->files === []) {
270		return $this->ignorePaths;
271		}
272	6	$ignorePaths = [];
273	6	foreach ($phpDocumentor->files->children() as $child) {
274	6	if ($child->getName() === 'ignore') {
275	6	$ignorePaths[] = (string) $child;
276		}
277		}
278
279	6	if (count($ignorePaths) === 0) {
280	5	return $this->ignorePaths;
281		}
282
283	1	return $ignorePaths;
284		}
285
286		/**
287		* Builds the outputDirectory part of the array from the configuration xml.
288		*/
289	6	private function buildOutputDirectory(SimpleXMLElement $phpDocumentor): string
290		{
291	6	if ((array) $phpDocumentor->transformer === []) {
292		return $this->outputDirectory;
293		}
294
295	6	if ((string) $phpDocumentor->transformer->target === '') {
296		return $this->outputDirectory;
297		}
298
299	6	return (string) $phpDocumentor->transformer->target;
300		}
301
302		/**
303		* Builds the directories that are used in the sourcePaths.
304		*
305		* @return string[]
306		*/
307	6	private function buildDirectories(SimpleXMLElement $phpDocumentor): array
308		{
309	6	if ((array) $phpDocumentor->files === []) {
310		return $this->directories;
311		}
312
313	6	if ((string) $phpDocumentor->files->directory === '') {
314		return $this->directories;
315		}
316
317	6	return (array) $phpDocumentor->files->directory;
318		}
319
320		/**
321		* Builds the sourcePaths part of the array from the configuration xml.
322		*
323		* @return Path[]
324		*/
325	6	private function buildSourcePaths(SimpleXMLElement $phpDocumentor): array
326		{
327	6	$sourcePaths = [];
328	6	$directories = $this->buildDirectories($phpDocumentor);
329
330	6	foreach ($directories as $directory) {
331	6	$sourcePaths[] = (new Dsn($directory))->getPath();
332		}
333
334	6	return $sourcePaths;
335		}
336
337		/**
338		* Builds the outputDirectory part of the array from the configuration xml.
339		*/
340	6	private function buildCacheDirectory(SimpleXMLElement $phpDocumentor): string
341		{
342	6	if ((array) $phpDocumentor->parser === []) {
343		return '/tmp/phpdoc-doc-cache';
344		}
345
346	6	if ((string) $phpDocumentor->parser->target === '') {
347	3	return '/tmp/phpdoc-doc-cache';
348		}
349
350	3	return (string) $phpDocumentor->parser->target;
351		}
352
353		/**
354		* Validates if the xml has a root element which name is phpdocumentor.
355		*
356		* @throws InvalidArgumentException if the root element of the xml is not phpdocumentor.
357		*/
358	7	private function validate(SimpleXMLElement $xml): void
359		{
360	7	if ($xml->getName() !== 'phpdocumentor') {
361	1	throw new InvalidArgumentException(
362	1	sprintf('Root element name should be phpdocumentor, %s found', $xml->getName())
363		);
364		}
365	6	}
366
367	6	private function buildEncoding(SimpleXMLElement $phpDocumentor)
368		{
369	6	if ((array) $phpDocumentor->parser === []) {
370		return 'utf-8';
371		}
372
373	6	if ((string) $phpDocumentor->parser->encoding === '') {
374		return 'utf-8';
375		}
376
377	6	return (string) $phpDocumentor->parser->encoding;
378		}
379		}
380

phpDocumentor / phpDocumentor

Version2::buildIgnoreHidden() A last analyzed 2019-11-23 16:53 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Version2::buildIgnoreHidden() A
last analyzed 2019-11-23 16:53 UTC