Collection - Code Metrics - Inspection of "add missing calls to trigger_error in deprecated c..." - Innmind/Immutable - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( cad621...d8b57f )

by Baptiste

created 2017-02-04 17:20 UTC

Collection D

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	800
Duplicated Lines	20 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

95.68%

Importance

Changes

Metric	Value
wmc	97
lcom	1
cbo	6
dl	160
loc	800
ccs	266
cts	278
cp	0.9568
rs	4.4444
c	0
b	0
f	0

69 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	toPrimitive()	0	4	1
A	filter()	0	14	2
A	intersect()	0	7	1
A	chunk()	11	11	2
A	shift()	0	7	1
A	reduce()	0	4	1
A	search()	0	4	1
A	uintersect()	0	8	1
A	keyIntersect()	0	7	1
A	map()	0	4	1
A	pad()	0	4	1
A	pop()	0	7	1
A	sum()	0	4	1
A	diff()	0	4	1
A	flip()	0	4	1
A	keys()	0	12	2
A	push()	0	7	1
A	rand()	0	17	3
A	merge()	0	7	1
A	slice()	0	9	2
A	udiff()	0	8	1
A	column()	0	8	1
A	splice()	0	7	1
A	unique()	0	4	1
A	values()	0	4	1
A	product()	0	4	1
A	replace()	0	7	1
A	reverse()	0	4	1
A	unshift()	0	7	1
A	keyDiff()	0	7	1
A	ukeyDiff()	0	8	1
A	associativeDiff()	0	7	1
A	hasKey()	0	10	2
A	countValues()	0	4	1
A	ukeyIntersect()	0	8	1
A	associativeIntersect()	0	7	1
A	sort()	11	11	2
A	associativeSort()	11	11	2
A	keySort()	11	11	2
A	ukeySort()	11	11	2
A	reverseSort()	11	11	2
A	usort()	11	11	2
A	associativeReverseSort()	11	11	2
A	keyReverseSort()	11	11	2
A	uassociativeSort()	11	11	2
A	naturalSort()	11	11	2
A	first()	8	8	2
A	last()	10	10	2
A	each()	0	8	2
A	join()	0	4	1
A	shuffle()	11	11	2
A	take()	0	20	4
A	grep()	0	8	2
A	set()	0	7	1
A	contains()	0	4	1
A	get()	0	4	1
A	walk()	10	10	2
A	unset()	0	14	2
A	count()	0	4	1
A	current()	0	4	1
A	key()	0	4	1
A	next()	0	4	1
A	rewind()	0	4	1
A	valid()	0	4	1
A	offsetExists()	0	4	1
A	offsetGet()	0	11	2
A	offsetSet()	0	4	1
A	offsetUnset()	0	4	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Collection often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Collection, and based on these observations, apply Extract Interface, too.

<?php
declare(strict_types = 1);

namespace Innmind\Immutable;

use Innmind\Immutable\Exception\SortException;
use Innmind\Immutable\Exception\OutOfBoundException;
use Innmind\Immutable\Exception\RuntimeException;
use Innmind\Immutable\Exception\InvalidArgumentException;
use Innmind\Immutable\Exception\LogicException;

/**
 * @deprecated To be removed in 2.0
 */
class Collection implements CollectionInterface

{
    private $values;

    public function __construct(array $values)
    {
        $this->values = $values;

        @trigger_error(
// For example instead of
@mkdir($dir);

// Better use
if (@mkdir($dir) === false) {
    throw new \RuntimeException('The directory '.$dir.' could not be created.');
}
            'Uset Set, Map or Stream instead',
            E_USER_DEPRECATED
        );
    }

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

    /**
     * {@inheritdoc}
     */
    public function filter(callable $filter = null): CollectionInterface
    {
        if ($filter === null) {
            $values = array_filter($this->values);
        } else {
            $values = array_filter(
                $this->values,
                $filter,
                ARRAY_FILTER_USE_BOTH
            );
        }

        return new self($values);

    }

    /**
     * {@inheritdoc}
     */
    public function intersect(CollectionInterface $collection): CollectionInterface
    {
        return new self(array_intersect(

            $this->values,
            $collection->toPrimitive()
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function chunk(int $size): CollectionInterface

    {
        $chunks = array_chunk($this->values, $size);
        $subs = [];

        foreach ($chunks as $chunk) {
            $subs[] = new self($chunk);

        }

        return new self($subs);

    }

    /**
     * {@inheritdoc}
     */
    public function shift(): CollectionInterface
    {
        $values = $this->values;
        array_shift($values);

        return new self($values);

    }

    /**
     * {@inheritdoc}
     */
    public function reduce(callable $reducer, $initial = null)
    {
        return array_reduce($this->values, $reducer, $initial);
    }

    /**
     * {@inheritdoc}
     */
    public function search($needle, bool $strict = true)
    {
        return array_search($needle, $this->values, (bool) $strict);
    }

    /**
     * {@inheritdoc}
     */
    public function uintersect(CollectionInterface $collection, callable $intersecter): CollectionInterface
    {
        return new self(array_uintersect(

            $this->values,
            $collection->toPrimitive(),
            $intersecter
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function keyIntersect(CollectionInterface $collection): CollectionInterface
    {
        return new self(array_intersect_key(

            $this->values,
            $collection->toPrimitive()
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function map(callable $mapper): CollectionInterface
    {
        return new self(array_map($mapper, $this->values));

    }

    /**
     * {@inheritdoc}
     */
    public function pad(int $size, $value): CollectionInterface
    {
        return new self(array_pad($this->values, $size, $value));

    }

    /**
     * {@inheritdoc}
     */
    public function pop(): CollectionInterface
    {
        $values = $this->values;
        array_pop($values);

        return new self($values);

    }

    /**
     * {@inheritdoc}
     */
    public function sum()
    {
        return array_sum($this->values);
    }

    /**
     * {@inheritdoc}
     */
    public function diff(CollectionInterface $collection): CollectionInterface
    {
        return new self(array_diff($this->values, $collection->toPrimitive()));

    }

    /**
     * {@inheritdoc}
     */
    public function flip(): CollectionInterface
    {
        return new self(array_flip($this->values));

    }

    /**
     * {@inheritdoc}
     */
    public function keys($search = null, bool $strict = true): CollectionInterface
    {
        $args = func_get_args();

        if (count($args) > 0) {
            $keys = array_keys($this->values, $search, (bool) $strict);
        } else {
            $keys = array_keys($this->values);
        }

        return new self($keys);

    }

    /**
     * {@inheritdoc}
     */
    public function push($value): CollectionInterface
    {
        $values = $this->values;
        array_push($values, $value);

        return new self($values);

    }

    /**
     * {@inheritdoc}
     */
    public function rand(int $num = 1): CollectionInterface
    {
        if ($num > $this->count()) {
            throw new OutOfBoundException(
                'Trying to return a wider collection than the current one'
            );
        }

        $keys = (array) array_rand($this->values, $num);
        $values = [];

        foreach ($keys as $key) {
            $values[$key] = $this->values[$key];
        }

        return new self($values);

    }

    /**
     * {@inheritdoc}
     */
    public function merge(CollectionInterface $collection): CollectionInterface
    {
        return new self(array_merge(

            $this->values,
            $collection->toPrimitive()
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function slice(int $offset, int $length = null, bool $preserveKeys = false): CollectionInterface
    {
        return new self(array_slice(

            $this->values,
            $offset,
            $length === null ? null : $length,
            $preserveKeys
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function udiff(CollectionInterface $collection, callable $differ): CollectionInterface
    {
        return new self(array_udiff(

            $this->values,
            $collection->toPrimitive(),
            $differ
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function column($key, $indexKey = null): CollectionInterface
    {
        return new self(array_column(

            $this->values,
            $key,
            $indexKey
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function splice(int $offset, int $length = 0, $replacement = []): CollectionInterface
    {
        $values = $this->values;
        array_splice($values, $offset, $length, $replacement);

        return new self($values);

    }

    /**
     * {@inheritdoc}
     */
    public function unique(int $flags = self::SORT_REGULAR): CollectionInterface
    {
        return new self(array_unique($this->values, $flags));

    }

    /**
     * {@inheritdoc}
     */
    public function values(): CollectionInterface
    {
        return new self(array_values($this->values));

    }

    /**
     * {@inheritdoc}
     */
    public function product()
    {
        return array_product($this->values);
    }

    /**
     * {@inheritdoc}
     */
    public function replace(CollectionInterface $collection): CollectionInterface
    {
        return new self(array_replace(

            $this->values,
            $collection->toPrimitive()
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function reverse(bool $preserveKeys = false): CollectionInterface
    {
        return new self(array_reverse($this->values, $preserveKeys));

    }

    /**
     * {@inheritdoc}
     */
    public function unshift($value): CollectionInterface
    {
        $values = $this->values;
        array_unshift($values, $value);

        return new self($values);

    }

    /**
     * {@inheritdoc}
     */
    public function keyDiff(CollectionInterface $collection): CollectionInterface
    {
        return new self(array_diff_key(

            $this->values,
            $collection->toPrimitive()
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function ukeyDiff(CollectionInterface $collection, callable $differ): CollectionInterface
    {
        return new self(array_diff_ukey(

            $this->values,
            $collection->toPrimitive(),
            $differ
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function associativeDiff(CollectionInterface $collection): CollectionInterface
    {
        return new self(array_diff_assoc(

            $this->values,
            $collection->toPrimitive()
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function hasKey($key, bool $strict = true): bool
    {
        if ($strict === true) {
            $bool = array_key_exists($key, $this->values);
        } else {
            $bool = isset($this->values[$key]);
        }

        return $bool;
    }

    /**
     * {@inheritdoc}
     */
    public function countValues(): CollectionInterface
    {
        return new self(array_count_values($this->values));

    }

    /**
     * {@inheritdoc}
     */
    public function ukeyIntersect(CollectionInterface $collection, callable $intersecter): CollectionInterface
    {
        return new self(array_intersect_ukey(

            $this->values,
            $collection->toPrimitive(),
            $intersecter
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function associativeIntersect(CollectionInterface $collection): CollectionInterface
    {
        return new self(array_intersect_assoc(

            $this->values,
            $collection->toPrimitive()
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function sort(int $flags = self::SORT_REGULAR): CollectionInterface

    {
        $values = $this->values;
        $bool = sort($values, $flags);

        if ($bool === false) {
            throw new SortException('Sort failure');
        }

        return new self($values);

    }

    /**
     * {@inheritdoc}
     */
    public function associativeSort(int $flags = self::SORT_REGULAR): CollectionInterface

    {
        $values = $this->values;
        $bool = asort($values, $flags);

        if ($bool === false) {
            throw new SortException('Sort failure');
        }

        return new self($values);

    }

    /**
     * {@inheritdoc}
     */
    public function keySort(int $flags = self::SORT_REGULAR): CollectionInterface

    {
        $values = $this->values;
        $bool = ksort($values, $flags);

        if ($bool === false) {
            throw new SortException('Sort failure');
        }

        return new self($values);

    }

    /**
     * {@inheritdoc}
     */
    public function ukeySort(callable $sorter): CollectionInterface

    {
        $values = $this->values;
        $bool = uksort($values, $sorter);

        if ($bool === false) {
            throw new SortException('Sort failure');
        }

        return new self($values);

    }

    /**
     * {@inheritdoc}
     */
    public function reverseSort(int $flags = self::SORT_REGULAR): CollectionInterface

    {
        $values = $this->values;
        $bool = rsort($values, $flags);

        if ($bool === false) {
            throw new SortException('Sort failure');
        }

        return new self($values);

    }

    /**
     * {@inheritdoc}
     */
    public function usort(callable $sorter): CollectionInterface

    {
        $values = $this->values;
        $bool = usort($values, $sorter);

        if ($bool === false) {
            throw new SortException('Sort failure');
        }

        return new self($values);

    }

    /**
     * {@inheritdoc}
     */
    public function associativeReverseSort(int $flags = self::SORT_REGULAR): CollectionInterface

    {
        $values = $this->values;
        $bool = arsort($values, $flags);

        if ($bool === false) {
            throw new SortException('Sort failure');
        }

        return new self($values);

    }

    /**
     * {@inheritdoc}
     */
    public function keyReverseSort(int $flags = self::SORT_REGULAR): CollectionInterface

    {
        $values = $this->values;
        $bool = krsort($values, $flags);

        if ($bool === false) {
            throw new SortException('Sort failure');
        }

        return new self($values);

    }

    /**
     * {@inheritdoc}
     */
    public function uassociativeSort(callable $sorter): CollectionInterface

    {
        $values = $this->values;
        $bool = uasort($values, $sorter);

        if ($bool === false) {
            throw new SortException('Sort failure');
        }

        return new self($values);

    }

    /**
     * {@inheritdoc}
     */
    public function naturalSort(): CollectionInterface

    {
        $values = $this->values;
        $bool = natsort($values);

        if ($bool === false) {
            throw new SortException('Sort failure');
        }

        return new self($values);

    }

    /**
     * {@inheritdoc}
     */
    public function first()

    {
        if ($this->count() === 0) {
            throw new OutOfBoundException('There is no first item');
        }

        return array_values($this->values)[0];
    }

    /**
     * {@inheritdoc}
     */
    public function last()

    {
        if ($this->count() === 0) {
            throw new OutOfBoundException('There is no last item');
        }

        $values = array_values($this->values);

        return end($values);
    }

    /**
     * {@inheritdoc}
     */
    public function each(callable $callback): CollectionInterface
    {
        foreach ($this->values as $key => $value) {
            $callback($key, $value);
        }

        return $this;
class Author {
    private $name;

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

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * {@inheritdoc}
     */
    public function join(string $separator): string
    {
        return implode($separator, $this->values);
    }

    /**
     * {@inheritdoc}
     */
    public function shuffle(): CollectionInterface

    {
        $values = $this->values;
        $result = shuffle($values);

        if ($result === false) {
            throw new RuntimeException('Shuffle operation failed');
        }

        return new self($values);

    }

    /**
     * {@inheritdoc}
     */
    public function take(int $size, bool $preserveKeys = false): CollectionInterface
    {
        $took = [];
        $keys = array_keys($this->values);

        while (count($took) < $size) {
            do {
                $random = mt_rand(0, count($keys) - 1);
            } while (!isset($keys[$random]));
            $key = $keys[$random];
            $took[$key] = $this->values[$key];
            unset($keys[$random]);
        }

        if ($preserveKeys === false) {
            $took = array_values($took);
        }

        return new self($took);

    }

    /**
     * {@inheritdoc}
     */
    public function grep(string $pattern, bool $revert = false): CollectionInterface
    {
        return new self(preg_grep(

            $pattern,
            $this->values,
            $revert === false ? 0 : PREG_GREP_INVERT
        ));
    }

    /**
     * {@inheritdoc}
     */
    public function set($key, $value): CollectionInterface
    {
        $values = $this->values;
        $values[$key] = $value;

        return new self($values);

    }

    /**
     * {@inheritdoc}
     */
    public function contains($value): bool
    {
        return in_array($value, $this->values, true);
    }

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

    /**
     * {@inheritdoc}
     */
    public function walk(callable $walker): CollectionInterface

    {
        $values = $this->values;

        if (array_walk($values, $walker) === false) {
            throw new RuntimeException('Walk operation failed');
        }

        return new self($values);

    }

    /**
     * {@inheritdoc}
     */
    public function unset($index): CollectionInterface
    {
        if (!$this->hasKey($index)) {
            throw new InvalidArgumentException(sprintf(
                'Unknown index %s',
                $index
            ));
        }

        $values = $this->values;
        unset($values[$index]);

        return new self($values);

    }

    /**
     * {@inheritdoc}
     */
    public function count(): int
    {
        return count($this->values);
    }

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

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

    /**
     * {@inheritdoc}
     */
    public function next()
    {
        next($this->values);
    }

    /**
     * {@inheritdoc}
     */
    public function rewind()
    {
        reset($this->values);
    }

    /**
     * {@inheritdoc}
     */
    public function valid(): bool
    {
        return $this->key() !== null;
    }

    /**
     * {@inheritdoc}
     */
    public function offsetExists($offset): bool
    {
        return $this->hasKey($offset);
    }

    /**
     * {@inheritdoc}
     */
    public function offsetGet($offset)
    {
        if (!$this->hasKey($offset)) {
            throw new InvalidArgumentException(sprintf(
                'Unknown index %s',
                $offset
            ));
        }

        return $this->values[$offset];
    }

    /**
     * {@inheritdoc}
     */
    public function offsetSet($offset, $value)
    {
        throw new LogicException('You can\'t modify an immutable collection');
    }

    /**
     * {@inheritdoc}
     */
    public function offsetUnset($offset)
    {
        throw new LogicException('You can\'t modify an immutable collection');
    }
}


1		<?php
2		declare(strict_types = 1);
3
4		namespace Innmind\Immutable;
5
6		use Innmind\Immutable\Exception\SortException;
7		use Innmind\Immutable\Exception\OutOfBoundException;
8		use Innmind\Immutable\Exception\RuntimeException;
9		use Innmind\Immutable\Exception\InvalidArgumentException;
10		use Innmind\Immutable\Exception\LogicException;
11
12		/**
13		* @deprecated To be removed in 2.0
14		*/
15		class Collection implements CollectionInterface
		0 ignored issues – show Deprecated Code introduced 2016-07-15 12:18 UTC by Report Bug Copy Issue Report The interface `Innmind\Immutable\CollectionInterface` has been deprecated with message: To be removed in 2.0 This class, trait or interface has been deprecated. The supplier of the file has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the type will be removed from the class and what other constant to use instead. Loading history...
16		{
17		private $values;
18
19	139	public function __construct(array $values)
20		{
21	139	$this->values = $values;
22
23	139	@trigger_error(
		0 ignored issues – show Security Best Practice introduced 2017-02-04 17:24 UTC by Report Bug Copy Issue Report It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended. If you suppress an error, we recommend checking for the error condition explicitly: // For example instead of @mkdir($dir); // Better use if (@mkdir($dir) === false) { throw new \RuntimeException('The directory '.$dir.' could not be created.'); } Loading history...
24	139	'Uset Set, Map or Stream instead',
25	139	E_USER_DEPRECATED
26		);
27	139	}
28
29		/**
30		* {@inheritdoc}
31		*/
32	97	public function toPrimitive()
33		{
34	97	return $this->values;
35		}
36
37		/**
38		* {@inheritdoc}

Innmind / Immutable

GitHub Access Token became invalid