PathIterator::tryGotoNextIterationElement() - Code Metrics - SuRaMoN/simplexmlreader - Measure and Improve Code Quality continuously with Scrutinizer

PathIterator::tryGotoNextIterationElement() C
last analyzed 2017-06-26 13:39 UTC

↳ Parent: PathIterator

Complexity

Conditions	12
Paths	30

Size

Total Lines	38
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	38
rs	5.1612
c	0
b	0
f	0
cc	12
eloc	20
nc	30
nop	0

How to fix Complexity

<?php

namespace SimpleXmlReader;

use XMLReader;
use Iterator;
use DOMDocument;

class PathIterator implements Iterator
{
    const IS_MATCH = 'IS_MATCH';
    const DESCENDANTS_COULD_MATCH = 'DESCENDANTS_COULD_MATCH';
    const DESCENDANTS_CANT_MATCH = 'DESCENDANTS_CANT_MATCH';

    protected $reader;
    protected $searchPath;
    protected $searchCrumbs;
    protected $crumbs;
    protected $currentDomExpansion;
    protected $rewindCount;
    protected $isValid;
    protected $returnType;

    public function __construct(ExceptionThrowingXMLReader $reader, $path, $returnType)
    {
        $this->reader = $reader;
        $this->searchPath = $path;
        $this->searchCrumbs = explode('/', $path);
        $this->crumbs = array();
        $this->matchCount = -1;
class MyClass { }

$x = new MyClass();
$x->foo = true;
        $this->rewindCount = 0;
        $this->isValid = false;
        $this->returnType = $returnType;
    }

    public function current()
    {
        return $this->currentDomExpansion;
    }

    public function key()
    {
        return $this->matchCount;
    }

    public function next()
    {
        $this->isValid = $this->tryGotoNextIterationElement();

        if ($this->isValid) {
            $this->matchCount += 1;
            $this->currentDomExpansion = $this->getXMLObject();
        }
    }

    public function rewind()
    {
        $this->rewindCount += 1;
        if ($this->rewindCount > 1) {
            throw new XmlException('Multiple rewinds not supported');
        }
        $this->next();
    }

    public function valid()
    {
        return $this->isValid;
    }

    protected function getXMLObject()
    {
        switch ($this->returnType) {
            case SimpleXMLReader::RETURN_DOM:
                return $this->reader->expand();

            case SimpleXMLReader::RETURN_INNER_XML_STRING:
                return $this->reader->readInnerXML();

            case SimpleXMLReader::RETURN_OUTER_XML_STRING:
                return $this->reader->readOuterXML();

            case SimpleXMLReader::RETURN_SIMPLE_XML:
                $simplexml = simplexml_import_dom($this->reader->expand(new DOMDocument('1.0')));
                if (false === $simplexml) {
                    throw new XMlException('Failed to create a SimpleXMLElement from the current XML node (invalid XML?)');
                }

                return $simplexml;

            default:
                throw new Exception(sprintf("Unknown return type: %s", $this->returnType));
        }
    }

    protected function pathIsMatching()
    {
        if (count($this->crumbs) > count($this->searchCrumbs)) {
            return self::DESCENDANTS_CANT_MATCH;
        }
        foreach ($this->crumbs as $i => $crumb) {
            $searchCrumb = $this->searchCrumbs[$i];
            if ($searchCrumb == $crumb || $searchCrumb == '*') {
                continue;
            }
            return self::DESCENDANTS_CANT_MATCH;
        }
        if (count($this->crumbs) == count($this->searchCrumbs)) {
            return self::IS_MATCH;
        }
        return self::DESCENDANTS_COULD_MATCH;
    }

    public function tryGotoNextIterationElement()
    {
        $r = $this->reader;

        if ($r->nodeType == XMLReader::NONE) {
            // first time we do a read from the xml
            if (! $r->tryRead()) { return false; }
        } else {
            // if we have already had a match
            if (! $r->tryNext()) { return false; }
        }

        while (true) {
            // search for open tag
            while ($r->nodeType != XMLReader::ELEMENT) {
                if (! $r->tryRead()) { return false; }
            }

            // fill crumbs
            array_splice($this->crumbs, $r->depth, count($this->crumbs), array($r->name));

            switch ($this->pathIsMatching()) {

                case self::DESCENDANTS_COULD_MATCH:
                    if (! $r->tryRead()) { return false; }
                    continue 2;

                case self::DESCENDANTS_CANT_MATCH:
                    if (! $r->tryNext()) { return false; }
                    continue 2;

                case self::IS_MATCH:
                    return true;
            }

            return false;
        }
    }
}


1			<?php
2
3			namespace SimpleXmlReader;
4
5			use XMLReader;
6			use Iterator;
7			use DOMDocument;
8
9			class PathIterator implements Iterator
10			{
11			const IS_MATCH = 'IS_MATCH';
12			const DESCENDANTS_COULD_MATCH = 'DESCENDANTS_COULD_MATCH';
13			const DESCENDANTS_CANT_MATCH = 'DESCENDANTS_CANT_MATCH';
14
15			protected $reader;
16			protected $searchPath;
17			protected $searchCrumbs;
18			protected $crumbs;
19			protected $currentDomExpansion;
20			protected $rewindCount;
21			protected $isValid;
22			protected $returnType;
23
24			public function __construct(ExceptionThrowingXMLReader $reader, $path, $returnType)
25			{
26			$this->reader = $reader;
27			$this->searchPath = $path;
28			$this->searchCrumbs = explode('/', $path);
29			$this->crumbs = array();
30			$this->matchCount = -1;
			0 ignored issues – show Bug introduced 2016-07-13 11:06 UTC by Report Bug Copy Issue Report The property `matchCount` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
31			$this->rewindCount = 0;
32			$this->isValid = false;
33			$this->returnType = $returnType;
34			}
35
36			public function current()
37			{
38			return $this->currentDomExpansion;
39			}
40
41			public function key()
42			{
43			return $this->matchCount;
44			}
45
46			public function next()
47			{
48			$this->isValid = $this->tryGotoNextIterationElement();
49
50			if ($this->isValid) {
51			$this->matchCount += 1;
52			$this->currentDomExpansion = $this->getXMLObject();
53			}
54			}
55
56			public function rewind()
57			{
58			$this->rewindCount += 1;
59			if ($this->rewindCount > 1) {
60			throw new XmlException('Multiple rewinds not supported');
61			}
62			$this->next();
63			}
64
65			public function valid()
66			{
67			return $this->isValid;
68			}
69
70			protected function getXMLObject()
71			{
72			switch ($this->returnType) {
73			case SimpleXMLReader::RETURN_DOM:
74			return $this->reader->expand();
75
76			case SimpleXMLReader::RETURN_INNER_XML_STRING:
77			return $this->reader->readInnerXML();
78
79			case SimpleXMLReader::RETURN_OUTER_XML_STRING:
80			return $this->reader->readOuterXML();
81
82			case SimpleXMLReader::RETURN_SIMPLE_XML:
83			$simplexml = simplexml_import_dom($this->reader->expand(new DOMDocument('1.0')));
84			if (false === $simplexml) {
85			throw new XMlException('Failed to create a SimpleXMLElement from the current XML node (invalid XML?)');
86			}
87
88			return $simplexml;
89
90			default:
91			throw new Exception(sprintf("Unknown return type: %s", $this->returnType));
92			}
93			}
94
95			protected function pathIsMatching()
96			{
97			if (count($this->crumbs) > count($this->searchCrumbs)) {
98			return self::DESCENDANTS_CANT_MATCH;
99			}
100			foreach ($this->crumbs as $i => $crumb) {
101			$searchCrumb = $this->searchCrumbs[$i];
102			if ($searchCrumb == $crumb \|\| $searchCrumb == '*') {
103			continue;
104			}
105			return self::DESCENDANTS_CANT_MATCH;
106			}
107			if (count($this->crumbs) == count($this->searchCrumbs)) {
108			return self::IS_MATCH;
109			}
110			return self::DESCENDANTS_COULD_MATCH;
111			}
112
113			public function tryGotoNextIterationElement()
114			{
115			$r = $this->reader;
116
117			if ($r->nodeType == XMLReader::NONE) {
118			// first time we do a read from the xml
119			if (! $r->tryRead()) { return false; }
120			} else {
121			// if we have already had a match
122			if (! $r->tryNext()) { return false; }
123			}
124
125			while (true) {
126			// search for open tag
127			while ($r->nodeType != XMLReader::ELEMENT) {
128			if (! $r->tryRead()) { return false; }
129			}
130
131			// fill crumbs
132			array_splice($this->crumbs, $r->depth, count($this->crumbs), array($r->name));
133
134			switch ($this->pathIsMatching()) {
135
136			case self::DESCENDANTS_COULD_MATCH:
137			if (! $r->tryRead()) { return false; }
138			continue 2;
139
140			case self::DESCENDANTS_CANT_MATCH:
141			if (! $r->tryNext()) { return false; }
142			continue 2;
143
144			case self::IS_MATCH:
145			return true;
146			}
147
148			return false;
149			}
150			}
151			}
152

SuRaMoN / simplexmlreader

PathIterator::tryGotoNextIterationElement() C last analyzed 2017-06-26 13:39 UTC

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like

PathIterator::tryGotoNextIterationElement() C
last analyzed 2017-06-26 13:39 UTC