NodeWalker::next() - Code Metrics - Inspection of "Prepare to release 0.18.5" - thephpleague/commonmark - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 0.18.x ( c34984 )

by Colin

created 2019-06-20 01:27 UTC

NodeWalker::next() B

↳ Parent: NodeWalker

Complexity

Conditions	7
Paths	6

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	20
CRAP Score	7

Importance

Changes

Metric	Value
dl	0
loc	27
ccs	20
cts	20
cp	1
rs	8.5546
c	0
b	0
f	0
cc	7
nc	6
nop	0
crap	7

<?php

namespace League\CommonMark\Node;

class NodeWalker
{
    /**
     * @var Node
     */
    private $root;

    /**
     * @var Node
     */
    private $current;

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

    /**
     * @param Node $root
     */
    public function __construct(Node $root)
    {
        $this->root = $root;
        $this->current = $this->root;
        $this->entering = true;
    }

    /**
     * Returns an event which contains node and entering flag
     * (entering is true when we enter a Node from a parent or sibling,
     * and false when we reenter it from child)
     *
     * @return NodeWalkerEvent|null
     */
    public function next()
    {
        $current = $this->current;
        $entering = $this->entering;
        if (null === $current) {
            return;
        }

        if ($entering && $current->isContainer()) {
            if ($current->firstChild()) {
                $this->current = $current->firstChild();
                $this->entering = true;
            } else {
                $this->entering = false;
            }
        } elseif ($current === $this->root) {
            $this->current = null;
        } elseif (null === $current->next()) {
            $this->current = $current->parent();
            $this->entering = false;
        } else {
            $this->current = $current->next();
            $this->entering = true;
        }

        return new NodeWalkerEvent($current, $entering);
    }

    /**
     * Resets the iterator to resume at the specified node
     *
     * @param Node $node
     * @param bool $entering
     */
    public function resumeAt(Node $node, $entering = true)
    {
        $this->current = $node;
        $this->entering = $entering;
    }
}


1		<?php
2
3		namespace League\CommonMark\Node;
4
5		class NodeWalker
6		{
7		/**
8		* @var Node
9		*/
10		private $root;
11
12		/**
13		* @var Node
14		*/
15		private $current;
16
17		/**
18		* @var bool
19		*/
20		private $entering;
21
22		/**
23		* @param Node $root
24		*/
25	1944	public function __construct(Node $root)
26		{
27	1944	$this->root = $root;
28	1944	$this->current = $this->root;
29	1944	$this->entering = true;
30	1944	}
31
32		/**
33		* Returns an event which contains node and entering flag
34		* (entering is true when we enter a Node from a parent or sibling,
35		* and false when we reenter it from child)
36		*
37		* @return NodeWalkerEvent\|null
38		*/
39	1944	public function next()
40		{
41	1944	$current = $this->current;
42	1944	$entering = $this->entering;
43	1944	if (null === $current) {
44	1944	return;
45		}
46
47	1944	if ($entering && $current->isContainer()) {
48	1944	if ($current->firstChild()) {
49	1938	$this->current = $current->firstChild();
50	1938	$this->entering = true;
51	646	} else {
52	1943	$this->entering = false;
53		}
54	1944	} elseif ($current === $this->root) {
55	1944	$this->current = null;
56	1940	} elseif (null === $current->next()) {
57	1938	$this->current = $current->parent();
58	1938	$this->entering = false;
59	646	} else {
60	1278	$this->current = $current->next();
61	1278	$this->entering = true;
62		}
63
64	1944	return new NodeWalkerEvent($current, $entering);
65		}
66
67		/**
68		* Resets the iterator to resume at the specified node
69		*
70		* @param Node $node
71		* @param bool $entering
72		*/
73	390	public function resumeAt(Node $node, $entering = true)
74		{
75	390	$this->current = $node;
76	390	$this->entering = $entering;
77	390	}
78		}
79

thephpleague / commonmark

Push — 0.18.x ( c34984 )

NodeWalker::next() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like