Atom::getSingleComplexTypes() - Code Metrics - Inspection of "Feature/lang test (#59)" - simplepie/simplepie-ng - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 8146b2...061ea8 )

by Ryan

created 2018-02-05 06:11 UTC

Atom::getSingleComplexTypes() B

↳ Parent: Atom

Complexity

Conditions	6
Paths	20

Size

Total Lines	30
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	6
eloc	15
nc	20
nop	4
dl	0
loc	30
rs	8.439
c	0
b	0
f	0

<?php
/**
 * Copyright (c) 2017–2018 Ryan Parman <http://ryanparman.com>.
 * Copyright (c) 2017–2018 Contributors.
 *
 * http://opensource.org/licenses/Apache2.0
 */
declare(strict_types=1);

namespace SimplePie\Middleware\Xml;

use DOMXPath;
use ReflectionClass;
use SimplePie\Configuration as C;
use SimplePie\Mixin as Tr;
use SimplePie\Type as T;
use stdClass;

/**
 * Support for the Atom 1.0 grammar.
 *
 * @see https://tools.ietf.org/html/rfc4287
 * @see https://www.w3.org/wiki/Atom
 */
class Atom extends AbstractXmlMiddleware implements XmlInterface, C\SetLoggerInterface
{
    use Tr\LoggerTrait;

    /**
     * {@inheritdoc}
     */
    public function __invoke(stdClass $feedRoot, string $namespaceAlias, DOMXPath $xpath): void
    {
        // Top-level feed
        $path = ['feed'];

        $this->getNodeAttributes($feedRoot, $namespaceAlias, $xpath, $path);

        $feedFallback = [
            'base' => $feedRoot->base[$namespaceAlias]->getNode(),
            'lang' => $feedRoot->lang[$namespaceAlias]->getNode(),
        ];

        $this->getSingleScalarTypes($feedRoot, $namespaceAlias, $xpath, $path, $feedFallback);
        $this->getSingleComplexTypes($feedRoot, $namespaceAlias, $xpath, $path);
        $this->getMultipleComplexTypes($feedRoot, $namespaceAlias, $xpath, $path);

        // <entry> element
        $path = ['feed', 'entry'];

        foreach ($feedRoot->entry[$namespaceAlias] as $i => &$entry) {
            $cpath   = $path;
            $cpath[] = $i;

            $feedFallback = [
                'base' => $feedRoot->base[$namespaceAlias]->getNode(),
                'lang' => $feedRoot->lang[$namespaceAlias]->getNode(),
            ];

            $this->getNodeAttributes($entry, $namespaceAlias, $xpath, $cpath, $feedFallback);

            $entryFallback = [
                'base' => $entry->base[$namespaceAlias]->getNode(),
                'lang' => $entry->lang[$namespaceAlias]->getNode(),
            ];

            $this->getSingleScalarTypes($entry, $namespaceAlias, $xpath, $cpath, $entryFallback);
            $this->getSingleComplexTypes($entry, $namespaceAlias, $xpath, $cpath);
            $this->getMultipleComplexTypes($entry, $namespaceAlias, $xpath, $cpath);
        }
    }

    /**
     * {@inheritdoc}
     *
     * Supports valid and invalid variations.
     *
     * * http://www.w3.org/2005/Atom
     * * http://www.w3.org/2005/Atom/
     * * https://www.w3.org/2005/Atom
     * * https://www.w3.org/2005/Atom/
     */
    public function getSupportedNamespaces(): array
    {
        return [
            'http://www.w3.org/2005/Atom'              => 'atom10',
            '/https?:\/\/www\.w3\.org\/2005\/Atom\/?/' => 'atom10',
        ];
    }

    /**
     * Fetches attributes with a single, scalar value, on elements.
     *
     * @param stdClass $feedRoot       The root of the feed. This will be written-to when the parsing middleware runs.
     * @param string   $namespaceAlias The preferred namespace alias for a given XML namespace URI. Should be the result
     *                                 of a call to `SimplePie\Util\Ns`.
     * @param DOMXPath $xpath          The `DOMXPath` object with this middleware's namespace alias applied.
     * @param array    $path           The path of the XML traversal. Should begin with `<feed>` or `<channel>`,
     *                                 then `<entry>` or `<item>`.
     * @param array    $fallback       An array of attributes for default XML attributes. The default value is an
     *                                 empty array.
     *
     * @phpcs:disable Generic.Functions.OpeningFunctionBraceBsdAllman.BraceOnSameLine
     */
    protected function getNodeAttributes(
        object $feedRoot,
        string $namespaceAlias,
        DOMXPath $xpath,
        array $path,
        array $fallback = []
    ): void {
        // @phpcs:enable

        $attrs = [
            'base' => '@xml:base',
            'lang' => '@xml:lang',
        ];

        // Used for traversing up the tree for inheritance
        $pathMinusLastBit = $path;
        \array_pop($pathMinusLastBit);

        foreach ($attrs as $nodeName => $searchName) {
            $query = $this->generateQuery($namespaceAlias, \array_merge($path, [$searchName]));
            $xq    = $xpath->query($query);
            $this->addArrayProperty($feedRoot, $nodeName);
            $this->getLogger()->debug(\sprintf('%s is running an XPath query:', __CLASS__), [$query]);

            $feedRoot->{$nodeName}[$namespaceAlias] = (false !== $xq && $xq->length > 0)
                ? new T\Node($xq->item(0))
                : new T\Node($this->get($fallback, $nodeName));
        }
    }

    /**
     * Fetches elements with a single, scalar value.
     *
     * @param stdClass $feedRoot       The root of the feed. This will be written-to when the parsing middleware runs.
     * @param string   $namespaceAlias The preferred namespace alias for a given XML namespace URI. Should be the result
     *                                 of a call to `SimplePie\Util\Ns`.
     * @param DOMXPath $xpath          The `DOMXPath` object with this middleware's namespace alias applied.
     * @param array    $path           The path of the XML traversal. Should begin with `<feed>` or `<channel>`,
     *                                 then `<entry>` or `<item>`.
     * @param array    $fallback       An array of attributes for default XML attributes. The default value is an
     *                                 empty array.
     *
     * @phpcs:disable Generic.Functions.OpeningFunctionBraceBsdAllman.BraceOnSameLine
     */
    protected function getSingleScalarTypes(
        object $feedRoot,
        string $namespaceAlias,
        DOMXPath $xpath,
        array $path,
        array $fallback = []
    ): void {
        // @phpcs:enable

        $cpath = $path;
        $nodes = [];

        if (\is_int(\end($cpath))) {
            \array_pop($cpath);
        }

        if ('feed' === \end($cpath)) {
            $nodes = [
                'icon',
                'id',
                'logo',
                'published',
                'rights',
                'subtitle',
                'summary',
                'title',
                'updated',
            ];
        } elseif ('entry' === \end($cpath)) {
            $nodes = [
                'content',
                'id',
                'published',
                'rights',
                'summary',
                'title',
                'updated',
            ];
        }

        foreach ($nodes as $nodeName) {
            $query = $this->generateQuery($namespaceAlias, \array_merge($path, [$nodeName]));
            $xq    = $xpath->query($query);
            $this->addArrayProperty($feedRoot, $nodeName);
            $this->getLogger()->debug(\sprintf('%s is running an XPath query:', __CLASS__), [$query]);

            $feedRoot->{$nodeName}[$namespaceAlias] = (false !== $xq && $xq->length > 0)
                ? new T\Node($xq->item(0), $fallback)
                : new T\Node();
        }
    }

    /**
     * Fetches elements with a single, complex value.
     *
     * @param stdClass $feedRoot       The root of the feed. This will be written-to when the parsing middleware runs.
     * @param string   $namespaceAlias The preferred namespace alias for a given XML namespace URI. Should be the result
     *                                 of a call to `SimplePie\Util\Ns`.
     * @param DOMXPath $xpath          The `DOMXPath` object with this middleware's namespace alias applied.
     * @param array    $path           The path of the XML traversal. Should begin with `<feed>` or `<channel>`,
     *                                 then `<entry>` or `<item>`.
     *
     * @phpcs:disable Generic.Functions.OpeningFunctionBraceBsdAllman.BraceOnSameLine
     */
    protected function getSingleComplexTypes(
        object $feedRoot,
        string $namespaceAlias,
        DOMXPath $xpath,
        array $path
    ): void {
        // @phpcs:enable

        $cpath = $path;
        $nodes = [];

        if (\is_int(\end($cpath))) {
            \array_pop($cpath);
        }

        if ('feed' === \end($cpath)) {
            $nodes = [
                'generator' => T\Generator::class,
            ];
        }

        foreach ($nodes as $name => $class) {
            $query = $this->generateQuery($namespaceAlias, \array_merge($path, [$name]));
            $xq    = $xpath->query($query);
            $this->addArrayProperty($feedRoot, $name);
            $this->getLogger()->debug(\sprintf('%s is running an XPath query:', __CLASS__), [$query]);

            $feedRoot->{$name}[$namespaceAlias] = (false !== $xq && $xq->length > 0)
                ? new $class($xq->item(0), $this->getLogger())
                : null;
        }
    }

    /**
     * Fetches elements with a multiple, complex values.
     *
     * @param stdClass $feedRoot       The root of the feed. This will be written-to when the parsing middleware runs.
     * @param string   $namespaceAlias The preferred namespace alias for a given XML namespace URI. Should be the result
     *                                 of a call to `SimplePie\Util\Ns`.
     * @param DOMXPath $xpath          The `DOMXPath` object with this middleware's namespace alias applied.
     * @param array    $path           The path of the XML traversal. Should begin with `<feed>` or `<channel>`,
     *                                 then `<entry>` or `<item>`.
     *
     * @phpcs:disable Generic.Functions.OpeningFunctionBraceBsdAllman.BraceOnSameLine
     */
    protected function getMultipleComplexTypes(
        object $feedRoot,
        string $namespaceAlias,
        DOMXPath $xpath,
        array $path
    ): void {
        // @phpcs:enable

        $cpath = $path;
        $nodes = [];

        if (\is_int(\end($cpath))) {
            \array_pop($cpath);
        }

        if ('feed' === \end($cpath)) {
            $nodes = [
                'author'      => T\Person::class,
                'category'    => T\Category::class,
                'contributor' => T\Person::class,
                'entry'       => T\Entry::class,
                'link'        => T\Link::class,
            ];
        } elseif ('entry' === \end($cpath)) {
            $nodes = [
                'author'      => T\Person::class,
                'category'    => T\Category::class,
                'contributor' => T\Person::class,
                'link'        => T\Link::class,
            ];
        }

        foreach ($nodes as $name => $class) {
            $query = $this->generateQuery($namespaceAlias, \array_merge($path, [$name]));
            $xq    = $xpath->query($query);
            $this->addArrayProperty($feedRoot, $name);
            $this->getLogger()->debug(\sprintf('%s is running an XPath query:', __CLASS__), [$query]);

            $feedRoot->{$name}[$namespaceAlias] = [];

            foreach ($xq as $result) {
                // What kind of class is this?
                $rclass = (new ReflectionClass($class))
                    ->newInstanceWithoutConstructor();

                if ($rclass instanceof T\BranchInterface) {
                    $feedRoot->{$name}[$namespaceAlias][] = new $class(
                        $namespaceAlias,
                        $result,
                        $this->getLogger()
                    );
                } else {
                    $feedRoot->{$name}[$namespaceAlias][] = new $class(
                        $result,
                        $this->getLogger()
                    );
                }
            }
        }
    }
}


1			<?php
2			/**
3			* Copyright (c) 2017–2018 Ryan Parman <http://ryanparman.com>.
4			* Copyright (c) 2017–2018 Contributors.
5			*
6			* http://opensource.org/licenses/Apache2.0
7			*/
8			declare(strict_types=1);
9
10			namespace SimplePie\Middleware\Xml;
11
12			use DOMXPath;
13			use ReflectionClass;
14			use SimplePie\Configuration as C;
15			use SimplePie\Mixin as Tr;
16			use SimplePie\Type as T;
17			use stdClass;
18
19			/**
20			* Support for the Atom 1.0 grammar.
21			*
22			* @see https://tools.ietf.org/html/rfc4287
23			* @see https://www.w3.org/wiki/Atom
24			*/
25			class Atom extends AbstractXmlMiddleware implements XmlInterface, C\SetLoggerInterface
26			{
27			use Tr\LoggerTrait;
28
29			/**
30			* {@inheritdoc}
31			*/
32			public function __invoke(stdClass $feedRoot, string $namespaceAlias, DOMXPath $xpath): void
33			{
34			// Top-level feed
35			$path = ['feed'];
36
37			$this->getNodeAttributes($feedRoot, $namespaceAlias, $xpath, $path);
38
39			$feedFallback = [
40			'base' => $feedRoot->base[$namespaceAlias]->getNode(),
41			'lang' => $feedRoot->lang[$namespaceAlias]->getNode(),
42			];
43
44			$this->getSingleScalarTypes($feedRoot, $namespaceAlias, $xpath, $path, $feedFallback);
45			$this->getSingleComplexTypes($feedRoot, $namespaceAlias, $xpath, $path);
46			$this->getMultipleComplexTypes($feedRoot, $namespaceAlias, $xpath, $path);
47
48			// <entry> element
49			$path = ['feed', 'entry'];
50
51			foreach ($feedRoot->entry[$namespaceAlias] as $i => &$entry) {
52			$cpath = $path;
53			$cpath[] = $i;
54
55			$feedFallback = [
56			'base' => $feedRoot->base[$namespaceAlias]->getNode(),
57			'lang' => $feedRoot->lang[$namespaceAlias]->getNode(),
58			];
59
60			$this->getNodeAttributes($entry, $namespaceAlias, $xpath, $cpath, $feedFallback);
61
62			$entryFallback = [
63			'base' => $entry->base[$namespaceAlias]->getNode(),
64			'lang' => $entry->lang[$namespaceAlias]->getNode(),
65			];
66
67			$this->getSingleScalarTypes($entry, $namespaceAlias, $xpath, $cpath, $entryFallback);
68			$this->getSingleComplexTypes($entry, $namespaceAlias, $xpath, $cpath);
69			$this->getMultipleComplexTypes($entry, $namespaceAlias, $xpath, $cpath);
70			}
71			}
72
73			/**
74			* {@inheritdoc}
75			*
76			* Supports valid and invalid variations.
77			*
78			* * http://www.w3.org/2005/Atom
79			* * http://www.w3.org/2005/Atom/
80			* * https://www.w3.org/2005/Atom
81			* * https://www.w3.org/2005/Atom/
82			*/
83			public function getSupportedNamespaces(): array
84			{
85			return [
86			'http://www.w3.org/2005/Atom' => 'atom10',
87			'/https?:\/\/www\.w3\.org\/2005\/Atom\/?/' => 'atom10',
88			];
89			}
90
91			/**
92			* Fetches attributes with a single, scalar value, on elements.
93			*
94			* @param stdClass $feedRoot The root of the feed. This will be written-to when the parsing middleware runs.
95			* @param string $namespaceAlias The preferred namespace alias for a given XML namespace URI. Should be the result
96			* of a call to `SimplePie\Util\Ns`.
97			* @param DOMXPath $xpath The `DOMXPath` object with this middleware's namespace alias applied.
98			* @param array $path The path of the XML traversal. Should begin with `<feed>` or `<channel>`,
99			* then `<entry>` or `<item>`.
100			* @param array $fallback An array of attributes for default XML attributes. The default value is an
101			* empty array.
102			*
103			* @phpcs:disable Generic.Functions.OpeningFunctionBraceBsdAllman.BraceOnSameLine
104			*/
105			protected function getNodeAttributes(
106			object $feedRoot,
107			string $namespaceAlias,
108			DOMXPath $xpath,
109			array $path,
110			array $fallback = []
111			): void {
112			// @phpcs:enable
113
114			$attrs = [
115			'base' => '@xml:base',
116			'lang' => '@xml:lang',
117			];
118
119			// Used for traversing up the tree for inheritance
120			$pathMinusLastBit = $path;
121			\array_pop($pathMinusLastBit);
122
123			foreach ($attrs as $nodeName => $searchName) {
124			$query = $this->generateQuery($namespaceAlias, \array_merge($path, [$searchName]));
125			$xq = $xpath->query($query);
126			$this->addArrayProperty($feedRoot, $nodeName);
127			$this->getLogger()->debug(\sprintf('%s is running an XPath query:', __CLASS__), [$query]);
128
129			$feedRoot->{$nodeName}[$namespaceAlias] = (false !== $xq && $xq->length > 0)
130			? new T\Node($xq->item(0))
131			: new T\Node($this->get($fallback, $nodeName));
132			}
133			}
134
135			/**
136			* Fetches elements with a single, scalar value.
137			*
138			* @param stdClass $feedRoot The root of the feed. This will be written-to when the parsing middleware runs.
139			* @param string $namespaceAlias The preferred namespace alias for a given XML namespace URI. Should be the result
140			* of a call to `SimplePie\Util\Ns`.
141			* @param DOMXPath $xpath The `DOMXPath` object with this middleware's namespace alias applied.
142			* @param array $path The path of the XML traversal. Should begin with `<feed>` or `<channel>`,
143			* then `<entry>` or `<item>`.
144			* @param array $fallback An array of attributes for default XML attributes. The default value is an
145			* empty array.
146			*
147			* @phpcs:disable Generic.Functions.OpeningFunctionBraceBsdAllman.BraceOnSameLine
148			*/
149			protected function getSingleScalarTypes(
150			object $feedRoot,
151			string $namespaceAlias,
152			DOMXPath $xpath,
153			array $path,
154			array $fallback = []
155			): void {
156			// @phpcs:enable
157
158			$cpath = $path;
159			$nodes = [];
160
161			if (\is_int(\end($cpath))) {
162			\array_pop($cpath);
163			}
164
165			if ('feed' === \end($cpath)) {
166			$nodes = [
167			'icon',
168			'id',
169			'logo',
170			'published',
171			'rights',
172			'subtitle',
173			'summary',
174			'title',
175			'updated',
176			];
177			} elseif ('entry' === \end($cpath)) {
178			$nodes = [
179			'content',
180			'id',
181			'published',
182			'rights',
183			'summary',
184			'title',
185			'updated',
186			];
187			}
188
189			foreach ($nodes as $nodeName) {
190			$query = $this->generateQuery($namespaceAlias, \array_merge($path, [$nodeName]));
191			$xq = $xpath->query($query);
192			$this->addArrayProperty($feedRoot, $nodeName);
193			$this->getLogger()->debug(\sprintf('%s is running an XPath query:', __CLASS__), [$query]);
194
195			$feedRoot->{$nodeName}[$namespaceAlias] = (false !== $xq && $xq->length > 0)
196			? new T\Node($xq->item(0), $fallback)
197			: new T\Node();
198			}
199			}
200
201			/**
202			* Fetches elements with a single, complex value.
203			*
204			* @param stdClass $feedRoot The root of the feed. This will be written-to when the parsing middleware runs.
205			* @param string $namespaceAlias The preferred namespace alias for a given XML namespace URI. Should be the result
206			* of a call to `SimplePie\Util\Ns`.
207			* @param DOMXPath $xpath The `DOMXPath` object with this middleware's namespace alias applied.
208			* @param array $path The path of the XML traversal. Should begin with `<feed>` or `<channel>`,
209			* then `<entry>` or `<item>`.
210			*
211			* @phpcs:disable Generic.Functions.OpeningFunctionBraceBsdAllman.BraceOnSameLine
212			*/
213			protected function getSingleComplexTypes(
214			object $feedRoot,
215			string $namespaceAlias,
216			DOMXPath $xpath,
217			array $path
218			): void {
219			// @phpcs:enable
220
221			$cpath = $path;
222			$nodes = [];
223
224			if (\is_int(\end($cpath))) {
225			\array_pop($cpath);
226			}
227
228			if ('feed' === \end($cpath)) {
229			$nodes = [
230			'generator' => T\Generator::class,
231			];
232			}
233
234			foreach ($nodes as $name => $class) {
235			$query = $this->generateQuery($namespaceAlias, \array_merge($path, [$name]));
236			$xq = $xpath->query($query);
237			$this->addArrayProperty($feedRoot, $name);
238			$this->getLogger()->debug(\sprintf('%s is running an XPath query:', __CLASS__), [$query]);
239
240			$feedRoot->{$name}[$namespaceAlias] = (false !== $xq && $xq->length > 0)
241			? new $class($xq->item(0), $this->getLogger())
242			: null;
243			}
244			}
245
246			/**
247			* Fetches elements with a multiple, complex values.
248			*
249			* @param stdClass $feedRoot The root of the feed. This will be written-to when the parsing middleware runs.
250			* @param string $namespaceAlias The preferred namespace alias for a given XML namespace URI. Should be the result
251			* of a call to `SimplePie\Util\Ns`.
252			* @param DOMXPath $xpath The `DOMXPath` object with this middleware's namespace alias applied.
253			* @param array $path The path of the XML traversal. Should begin with `<feed>` or `<channel>`,
254			* then `<entry>` or `<item>`.
255			*
256			* @phpcs:disable Generic.Functions.OpeningFunctionBraceBsdAllman.BraceOnSameLine
257			*/
258			protected function getMultipleComplexTypes(
259			object $feedRoot,
260			string $namespaceAlias,
261			DOMXPath $xpath,
262			array $path
263			): void {
264			// @phpcs:enable
265
266			$cpath = $path;
267			$nodes = [];
268
269			if (\is_int(\end($cpath))) {
270			\array_pop($cpath);
271			}
272
273			if ('feed' === \end($cpath)) {
274			$nodes = [
275			'author' => T\Person::class,
276			'category' => T\Category::class,
277			'contributor' => T\Person::class,
278			'entry' => T\Entry::class,
279			'link' => T\Link::class,
280			];
281			} elseif ('entry' === \end($cpath)) {
282			$nodes = [
283			'author' => T\Person::class,
284			'category' => T\Category::class,
285			'contributor' => T\Person::class,
286			'link' => T\Link::class,
287			];
288			}
289
290			foreach ($nodes as $name => $class) {
291			$query = $this->generateQuery($namespaceAlias, \array_merge($path, [$name]));
292			$xq = $xpath->query($query);
293			$this->addArrayProperty($feedRoot, $name);
294			$this->getLogger()->debug(\sprintf('%s is running an XPath query:', __CLASS__), [$query]);
295
296			$feedRoot->{$name}[$namespaceAlias] = [];
297
298			foreach ($xq as $result) {
299			// What kind of class is this?
300			$rclass = (new ReflectionClass($class))
301			->newInstanceWithoutConstructor();
302
303			if ($rclass instanceof T\BranchInterface) {
304			$feedRoot->{$name}[$namespaceAlias][] = new $class(
305			$namespaceAlias,
306			$result,
307			$this->getLogger()
308			);
309			} else {
310			$feedRoot->{$name}[$namespaceAlias][] = new $class(
311			$result,
312			$this->getLogger()
313			);
314			}
315			}
316			}
317			}
318			}
319

simplepie / simplepie-ng

Push — master ( 8146b2...061ea8 )

Atom::getSingleComplexTypes() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like