XMLIterator::next() - Code Metrics - ThrusterIO/xml-iterator - Measure and Improve Code Quality continuously with Scrutinizer

XMLIterator::next() A
last analyzed 2016-09-22 13:16 UTC

↳ Parent: XMLIterator

Complexity

Conditions	4
Paths	3

Size

Total Lines	13
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	4

Importance

Changes

Metric	Value
dl	0
loc	13
ccs	8
cts	8
cp	1
rs	9.2
c	0
b	0
f	0
cc	4
eloc	7
nc	3
nop	0
crap	4

<?php

namespace Thruster\Component\XMLIterator;

use Iterator as IteratorInterface;

/**
 * Class XMLIterator
 *
 * @package Thruster\Component\XMLIterator
 * @author  Aurimas Niekis <[email protected]>
 */
class XMLIterator implements IteratorInterface
{
    /**
     * @var XMLReader
     */
    protected $reader;

    /**
     * @var int
     */
    private $index;

    /**
     * @var bool
     */
    private $lastRead;

    /**
     * @var array
     */
    private $elementStack;

    public function __construct(XMLReader $reader)
    {
        $this->reader = $reader;
    }

    /**
     * @return XMLReader
     */
    public function getReader() : XMLReader
    {
        return $this->reader;
    }

    /**
     * @param string $name
     *
     * @return bool|Node
     */
    public function moveToNextElementByName($name = null)
    {
        while (self::moveToNextElement()) {
            if (!$name || $name === $this->reader->name) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                break;
            }

            self::next();
        };

        return self::valid() ? self::current() : false;
    }

    public function moveToNextElement()
    {
        return $this->moveToNextByNodeType(XMLReader::ELEMENT);
    }

    /**
     * @param int $nodeType
     *
     * @return bool|Node
     */
    public function moveToNextByNodeType($nodeType)
    {
        if (null === self::valid()) {
            self::rewind();
        } elseif (self::valid()) {
            self::next();
        }

        while (self::valid()) {
            if ($this->reader->nodeType === $nodeType) {
                break;
            }

            self::next();
        }

        return self::valid() ? self::current() : false;
    }

    /**
     * @inheritdoc
     */
    public function rewind()
    {
        // this iterator can not really rewind
        if ($this->reader->nodeType === XMLREADER::NONE) {
            self::next();
        } elseif ($this->lastRead === null) {
            $this->lastRead = true;
        }

        $this->index = 0;
    }

    /**
     * @inheritdoc
     */
    public function valid()
    {
        return $this->lastRead;
    }

    /**
     * @return Node
     */
    public function current()
    {
        return new Node($this->reader);
    }

    /**
     * @inheritdoc
     */
    public function key()
    {
        return $this->index;
    }

    /**
     * @inheritdoc
     */
    public function next()
    {
        if ($this->lastRead = $this->reader->read() and $this->reader->nodeType === XMLReader::ELEMENT) {
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
            $depth                      = $this->reader->depth;
            $this->elementStack[$depth] = new Element($this->reader);

            if (count($this->elementStack) !== $depth + 1) {
                $this->elementStack = array_slice($this->elementStack, 0, $depth + 1);
            }
        }

        $this->index++;
    }

    /**
     * @return string
     */
    public function getNodePath() : string
    {
        return '/' . implode('/', $this->elementStack);
    }

    /**
     * @return string
     */
    public function getNodeTree() : string
    {
        $stack  = $this->elementStack;
        $buffer = '';

        /* @var $element Element */
        while ($element = array_pop($stack)) {
            $buffer = $element->getXMLElementAround($buffer);
        }

        return $buffer;
    }
}


ThrusterIO / xml-iterator

XMLIterator::next() A last analyzed 2016-09-22 13:16 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Logical Operators are used for Control-Flow

Duplication Side-by-Side

Filter issues like

XMLIterator::next() A
last analyzed 2016-09-22 13:16 UTC