FrameCollection::offsetSet() - Code Metrics - Inspection of "Fix issues with frameworks like Laravel on PHP7" - filp/whoops - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — v1 (#422)

unknown

created 2016-06-30 13:36 UTC

FrameCollection::offsetSet() A

↳ Parent: FrameCollection

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
cc	1
eloc	2
nc	1
nop	2
crap	1

<?php
/**
 * Whoops - php errors for cool kids
 * @author Filipe Dobreira <http://github.com/filp>
 */

namespace Whoops\Exception;

use ArrayAccess;
use ArrayIterator;
use Countable;
use IteratorAggregate;
use Serializable;
use UnexpectedValueException;

/**
 * Exposes a fluent interface for dealing with an ordered list
 * of stack-trace frames.
 */
class FrameCollection implements ArrayAccess, IteratorAggregate, Serializable, Countable
{
    /**
     * @var array[]
     */
    private $frames;

    /**
     * @param array $frames
     */
    public function __construct(array $frames)
    {
        $this->frames = array_map(function ($frame) {
            return new Frame($frame);
        }, $frames);
    }

    /**
     * Filters frames using a callable, returns the same FrameCollection
     *
     * @param  callable        $callable
     * @return FrameCollection
     */
    public function filter($callable)
    {
        $this->frames = array_filter($this->frames, $callable);
        return $this;
    }

    /**
     * Map the collection of frames
     *
     * @param  callable        $callable
     * @return FrameCollection
     */
    public function map($callable)
    {
        // Contain the map within a higher-order callable
        // that enforces type-correctness for the $callable
        $this->frames = array_map(function ($frame) use ($callable) {
            $frame = call_user_func($callable, $frame);

            if (!$frame instanceof Frame) {
                throw new UnexpectedValueException(
                    "Callable to " . __METHOD__ . " must return a Frame object"
                );
            }

            return $frame;
        }, $this->frames);

        return $this;
    }

    /**
     * Returns an array with all frames, does not affect
     * the internal array.
     *
     * @todo   If this gets any more complex than this,
     *         have getIterator use this method.
     * @see    FrameCollection::getIterator
     * @return array
     */
    public function getArray()
    {
        return $this->frames;
    }

    /**
     * @see IteratorAggregate::getIterator
     * @return ArrayIterator
     */
    public function getIterator()
    {
        return new ArrayIterator($this->frames);
    }

    /**
     * @see ArrayAccess::offsetExists
     * @param int $offset
     */
    public function offsetExists($offset)
    {
        return isset($this->frames[$offset]);
    }

    /**
     * @see ArrayAccess::offsetGet
     * @param int $offset
     */
    public function offsetGet($offset)
    {
        return $this->frames[$offset];
    }

    /**
     * @see ArrayAccess::offsetSet
     * @param int $offset
     */
    public function offsetSet($offset, $value)
    {
        throw new \Exception(__CLASS__ . ' is read only');
    }

    /**
     * @see ArrayAccess::offsetUnset
     * @param int $offset
     */
    public function offsetUnset($offset)
    {
        throw new \Exception(__CLASS__ . ' is read only');
    }

    /**
     * @see Countable::count
     * @return int
     */
    public function count()
    {
        return count($this->frames);
    }

    /**
     * @see Serializable::serialize
     * @return string
     */
    public function serialize()
    {
        return serialize($this->frames);
    }

    /**
     * @see Serializable::unserialize
     * @param string $serializedFrames
     */
    public function unserialize($serializedFrames)
    {
        $this->frames = unserialize($serializedFrames);
    }

    /**
     * @param Frame[] $frames Array of Frame instances, usually from $e->getPrevious()
     */
    public function prependFrames(array $frames)
    {
        $this->frames = array_merge($frames, $this->frames);
    }

    /**
     * Gets the innermost part of stack trace that is not the same as that of outer exception
     *
     * @param  FrameCollection $parentFrames Outer exception frames to compare tail against
     * @return Frame[]
     */
    public function topDiff(FrameCollection $parentFrames)
    {
        $diff = $this->frames;

        $parentFrames = $parentFrames->getArray();
        $p = count($parentFrames)-1;

        for ($i = count($diff)-1; $i >= 0 && $p >= 0; $i--) {
            /** @var Frame $tailFrame */
            $tailFrame = $diff[$i];
            if ($tailFrame->equals($parentFrames[$p])) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                unset($diff[$i]);
            }
            $p--;
        }
        return $diff;
    }
}


1		<?php
2		/**
3		* Whoops - php errors for cool kids
4		* @author Filipe Dobreira <http://github.com/filp>
5		*/
6
7		namespace Whoops\Exception;
8
9		use ArrayAccess;
10		use ArrayIterator;
11		use Countable;
12		use IteratorAggregate;
13		use Serializable;
14		use UnexpectedValueException;
15
16		/**
17		* Exposes a fluent interface for dealing with an ordered list
18		* of stack-trace frames.
19		*/
20		class FrameCollection implements ArrayAccess, IteratorAggregate, Serializable, Countable
21		{
22		/**
23		* @var array[]
24		*/
25		private $frames;
26
27		/**
28		* @param array $frames
29		*/
30	1	public function __construct(array $frames)
31		{
32		$this->frames = array_map(function ($frame) {
33	1	return new Frame($frame);
34	1	}, $frames);
35	1	}
36
37		/**
38		* Filters frames using a callable, returns the same FrameCollection
39		*
40		* @param callable $callable
41		* @return FrameCollection
42		*/
43	1	public function filter($callable)
44		{
45	1	$this->frames = array_filter($this->frames, $callable);
46	1	return $this;
47		}
48
49		/**
50		* Map the collection of frames
51		*
52		* @param callable $callable
53		* @return FrameCollection
54		*/
55		public function map($callable)
56		{
57		// Contain the map within a higher-order callable
58		// that enforces type-correctness for the $callable
59	2	$this->frames = array_map(function ($frame) use ($callable) {
60	2	$frame = call_user_func($callable, $frame);
61
62	2	if (!$frame instanceof Frame) {
63	1	throw new UnexpectedValueException(
64	1	"Callable to " . __METHOD__ . " must return a Frame object"
65	1	);
66		}
67
68	1	return $frame;
69	2	}, $this->frames);
70
71	1	return $this;
72		}
73
74		/**
75		* Returns an array with all frames, does not affect
76		* the internal array.
77		*
78		* @todo If this gets any more complex than this,
79		* have getIterator use this method.
80		* @see FrameCollection::getIterator
81		* @return array
82		*/
83	2	public function getArray()
84		{
85	2	return $this->frames;
86		}
87
88		/**
89		* @see IteratorAggregate::getIterator
90		* @return ArrayIterator
91		*/
92	2	public function getIterator()
93		{
94	2	return new ArrayIterator($this->frames);
95		}
96
97		/**
98		* @see ArrayAccess::offsetExists
99		* @param int $offset
100		*/
101	1	public function offsetExists($offset)
102		{
103	1	return isset($this->frames[$offset]);
104		}
105
106		/**
107		* @see ArrayAccess::offsetGet
108		* @param int $offset
109		*/
110	1	public function offsetGet($offset)
111		{
112	1	return $this->frames[$offset];
113		}
114
115		/**
116		* @see ArrayAccess::offsetSet
117		* @param int $offset
118		*/
119	1	public function offsetSet($offset, $value)
120		{
121	1	throw new \Exception(__CLASS__ . ' is read only');
122		}
123
124		/**
125		* @see ArrayAccess::offsetUnset
126		* @param int $offset
127		*/
128	1	public function offsetUnset($offset)
129		{
130	1	throw new \Exception(__CLASS__ . ' is read only');
131		}
132
133		/**
134		* @see Countable::count
135		* @return int
136		*/
137	2	public function count()
138		{
139	2	return count($this->frames);
140		}
141
142		/**
143		* @see Serializable::serialize
144		* @return string
145		*/
146	1	public function serialize()
147		{
148	1	return serialize($this->frames);
149		}
150
151		/**
152		* @see Serializable::unserialize
153		* @param string $serializedFrames
154		*/
155	1	public function unserialize($serializedFrames)
156		{
157	1	$this->frames = unserialize($serializedFrames);
158	1	}
159
160		/**
161		* @param Frame[] $frames Array of Frame instances, usually from $e->getPrevious()
162		*/
163		public function prependFrames(array $frames)
164		{
165		$this->frames = array_merge($frames, $this->frames);
166		}
167
168		/**
169		* Gets the innermost part of stack trace that is not the same as that of outer exception
170		*
171		* @param FrameCollection $parentFrames Outer exception frames to compare tail against
172		* @return Frame[]
173		*/
174	1	public function topDiff(FrameCollection $parentFrames)
175		{
176	1	$diff = $this->frames;
177
178	1	$parentFrames = $parentFrames->getArray();
179	1	$p = count($parentFrames)-1;
180
181	1	for ($i = count($diff)-1; $i >= 0 && $p >= 0; $i--) {
182		/** @var Frame $tailFrame */
183	1	$tailFrame = $diff[$i];
184	1	if ($tailFrame->equals($parentFrames[$p])) {
		0 ignored issues – show Documentation introduced 2015-11-21 13:08 UTC by Report Bug Copy Issue Report `$parentFrames[$p]` is of type `array`, but the function expects a `object<Whoops\Exception\Frame>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
185	1	unset($diff[$i]);
186	1	}
187	1	$p--;
188	1	}
189	1	return $diff;
190		}
191		}
192

filp / whoops

Pull Request — v1 (#422)

FrameCollection::offsetSet() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like