RoundRobinQueue::peek() - Code Metrics - Inspection of "Merge pull request #378 from carusogabriel/asserti..." - bernardphp/bernard - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 967239...06466a )

by Márk

created 2018-06-24 11:32 UTC

RoundRobinQueue::peek() B

↳ Parent: RoundRobinQueue

Complexity

Conditions	7
Paths	16

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	23
CRAP Score	7.2791

Importance

Changes

Metric	Value
dl	0
loc	32
ccs	23
cts	28
cp	0.8214
rs	8.4746
c	0
b	0
f	0
cc	7
nc	16
nop	2
crap	7.2791

<?php

namespace Bernard\Queue;

use Bernard\Envelope;
use Bernard\Queue;

class RoundRobinQueue implements Queue
{
    /**
     * @var Queue[]
     */
    protected $queues;

    /**
     * @var bool
     */
    protected $closed;

    /**
     * @var \SplObjectStorage
     */
    protected $envelopes;

    /**
     * @param Queue[] $queues
     */
    public function __construct(array $queues)
    {
        $this->validateQueues($queues);

        $this->queues = $this->indexQueues($queues);
        $this->envelopes = new \SplObjectStorage();
        $this->closed = false;
    }

    /**
     * {@inheritdoc}
     */
    public function enqueue(Envelope $envelope)
    {
        $this->verifyEnvelope($envelope);

        $this->queues[$envelope->getName()]->enqueue($envelope);
    }

    /**
     * {@inheritdoc}
     */
    public function dequeue()
    {
        $envelope = null;
        $checked = [];

        while (count($checked) < count($this->queues)) {
            $queue = current($this->queues);
            $envelope = $queue->dequeue();
            if (false === next($this->queues)) {
                reset($this->queues);
            }
            if ($envelope) {
                $this->envelopes->attach($envelope, $queue);
                break;
            } else {
                $checked[] = $queue;
            }
        }

        return $envelope;
    }

    /**
     * {@inheritdoc}
     */
    public function close()
    {
        if ($this->closed) {
            return;
        }

        foreach ($this->queues as $queue) {
            $queue->close();
        }

        $this->closed = true;
    }

    /**
     * {@inheritdoc}
     */
    public function peek($index = 0, $limit = 20)
    {
        $it = new \InfiniteIterator(new \ArrayIterator($this->queues));
        $envelopes = $drained = $indexes = [];
        foreach (array_keys($this->queues) as $name) {
            $indexes[$name] = 0;
        }
        $shift = 0;

        $key = key($this->queues);
        for ($it->rewind(); $it->key() != $key; $it->next()) {

            // noop
        }

        while (count($envelopes) < $limit && count($drained) < $it->count()) {
            $queue = $it->current();
            $name = $it->key();
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
            if ($peeked = $queue->peek($indexes[$name], 1)) {
                if ($shift < $index) {
                    ++$shift;
                    ++$indexes[$name];
                } else {
                    $envelopes[] = array_shift($peeked);
                }
            } else {
                $drained[$name] = true;
            }
            $it->next();
        }

        return $envelopes;
    }

    /**
     * {@inheritdoc}
     */
    public function acknowledge(Envelope $envelope)
    {
        if (!$this->envelopes->contains($envelope)) {
            throw new \DomainException(
                'Unrecognized queue specified: '.$envelope->getName()
            );
        }

        $queue = $this->envelopes[$envelope];
        $queue->acknowledge($envelope);
        $this->envelopes->detach($envelope);
    }

    /**
     * {@inheritdoc}
     */
    public function __toString()
    {
        return (string) current($this->queues);
    }

    /**
     * @return int
     */
    public function count()
    {
        return array_sum(array_map('count', $this->queues));
    }

    /**
     * @param Queue[] $queues
     */
    protected function validateQueues(array $queues)
    {
        if (empty($queues)) {
            throw new \DomainException('$queues cannot be empty');
        }

        $filtered = array_filter(
            $queues,
            function ($queue) {
                return !$queue instanceof Queue;
            }
        );
        if (!empty($filtered)) {
            throw new \DomainException('All elements of $queues must implement Queue');
        }
    }

    /**
     * @param Queue[] $queues
     *
     * @return Queue[]
     */
    protected function indexQueues(array $queues)
    {
        return array_combine(
            array_map(
                function ($queue) {
                    return (string) $queue;
                },
                $queues
            ),
            $queues
        );
    }

    /**
     * @param Envelope $envelope
     */
    protected function verifyEnvelope(Envelope $envelope)
    {
        $queue = $envelope->getName();
        if (isset($this->queues[$queue])) {
            return;
        }
        throw new \DomainException('Unrecognized queue specified: '.$queue);
    }
}


1		<?php
2
3		namespace Bernard\Queue;
4
5		use Bernard\Envelope;
6		use Bernard\Queue;
7
8		class RoundRobinQueue implements Queue
9		{
10		/**
11		* @var Queue[]
12		*/
13		protected $queues;
14
15		/**
16		* @var bool
17		*/
18		protected $closed;
19
20		/**
21		* @var \SplObjectStorage
22		*/
23		protected $envelopes;
24
25		/**
26		* @param Queue[] $queues
27		*/
28	11	public function __construct(array $queues)
29		{
30	11	$this->validateQueues($queues);
31
32	11	$this->queues = $this->indexQueues($queues);
33	11	$this->envelopes = new \SplObjectStorage();
34	11	$this->closed = false;
35	11	}
36
37		/**
38		* {@inheritdoc}
39		*/
40	8	public function enqueue(Envelope $envelope)
41		{
42	8	$this->verifyEnvelope($envelope);
43
44	6	$this->queues[$envelope->getName()]->enqueue($envelope);
45	6	}
46
47		/**
48		* {@inheritdoc}
49		*/
50	5	public function dequeue()
51		{
52	5	$envelope = null;
53	5	$checked = [];
54
55	5	while (count($checked) < count($this->queues)) {
56	5	$queue = current($this->queues);
57	5	$envelope = $queue->dequeue();
58	5	if (false === next($this->queues)) {
59	2	reset($this->queues);
60	2	}
61	5	if ($envelope) {
62	4	$this->envelopes->attach($envelope, $queue);
63	4	break;
64		} else {
65	4	$checked[] = $queue;
66		}
67	4	}
68
69	5	return $envelope;
70		}
71
72		/**
73		* {@inheritdoc}
74		*/
75	1	public function close()
76		{
77	1	if ($this->closed) {
78		return;
79		}
80
81	1	foreach ($this->queues as $queue) {
82	1	$queue->close();
83	1	}
84
85	1	$this->closed = true;
86	1	}
87
88		/**
89		* {@inheritdoc}
90		*/
91	1	public function peek($index = 0, $limit = 20)
92		{
93	1	$it = new \InfiniteIterator(new \ArrayIterator($this->queues));
94	1	$envelopes = $drained = $indexes = [];
95	1	foreach (array_keys($this->queues) as $name) {
96	1	$indexes[$name] = 0;
97	1	}
98	1	$shift = 0;
99
100	1	$key = key($this->queues);
101	1	for ($it->rewind(); $it->key() != $key; $it->next()) {
		0 ignored issues – show Unused Code introduced 2018-02-15 06:37 UTC by Report Bug Copy Issue Report This `for` loop is empty and can be removed. This check looks for `for` loops that have no statements or where all statements have been commented out. This may be the result of changes for debugging or the code may simply be obsolete. Consider removing the loop. Loading history...
102		// noop
103		}
104
105	1	while (count($envelopes) < $limit && count($drained) < $it->count()) {
106	1	$queue = $it->current();
107	1	$name = $it->key();
		0 ignored issues – show Bug introduced 2015-11-30 20:04 UTC by Report Bug Copy Issue Report Are you sure the assignment to `$name` is correct as `$it->key()` (which targets `InfiniteIterator::key()`) seems to always return null. This check looks for function or method calls that always return null and whose return value is assigned to a variable. class A { function getObject() { return null; } } $a = new A(); $object = $a->getObject(); The method `getObject()` can return nothing but null, so it makes no sense to assign that value to a variable. The reason is most likely that a function or method is imcomplete or has been reduced for debug purposes. Loading history...
108	1	if ($peeked = $queue->peek($indexes[$name], 1)) {
109	1	if ($shift < $index) {
110	1	++$shift;
111	1	++$indexes[$name];
112	1	} else {
113	1	$envelopes[] = array_shift($peeked);
114		}
115	1	} else {
116	1	$drained[$name] = true;
117		}
118	1	$it->next();
119	1	}
120
121	1	return $envelopes;
122		}
123
124		/**
125		* {@inheritdoc}
126		*/
127	1	public function acknowledge(Envelope $envelope)
128		{
129	1	if (!$this->envelopes->contains($envelope)) {
130		throw new \DomainException(
131		'Unrecognized queue specified: '.$envelope->getName()
132		);
133		}
134
135	1	$queue = $this->envelopes[$envelope];
136	1	$queue->acknowledge($envelope);
137	1	$this->envelopes->detach($envelope);
138	1	}
139
140		/**
141		* {@inheritdoc}
142		*/
143	1	public function __toString()
144		{
145	1	return (string) current($this->queues);
146		}
147
148		/**
149		* @return int
150		*/
151	1	public function count()
152		{
153	1	return array_sum(array_map('count', $this->queues));
154		}
155
156		/**
157		* @param Queue[] $queues
158		*/
159	11	protected function validateQueues(array $queues)
160		{
161	11	if (empty($queues)) {
162		throw new \DomainException('$queues cannot be empty');
163		}
164
165	11	$filtered = array_filter(
166	11	$queues,
167		function ($queue) {
168	11	return !$queue instanceof Queue;
169		}
170	11	);
171	11	if (!empty($filtered)) {
172		throw new \DomainException('All elements of $queues must implement Queue');
173		}
174	11	}
175
176		/**
177		* @param Queue[] $queues
178		*
179		* @return Queue[]
180		*/
181	11	protected function indexQueues(array $queues)
182		{
183	11	return array_combine(
184	11	array_map(
185	11	function ($queue) {
186	11	return (string) $queue;
187	11	},
188		$queues
189	11	),
190		$queues
191	11	);
192		}
193
194		/**
195		* @param Envelope $envelope
196		*/
197	8	protected function verifyEnvelope(Envelope $envelope)
198		{
199	8	$queue = $envelope->getName();
200	8	if (isset($this->queues[$queue])) {
201	6	return;
202		}
203	2	throw new \DomainException('Unrecognized queue specified: '.$queue);
204		}
205		}
206

bernardphp / bernard

GitHub Access Token became invalid

Push — master ( 967239...06466a )

RoundRobinQueue::peek() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like