Map - Code Metrics - Inspection of "use phpunit 6" - Innmind/Immutable - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 5a4bbb...3fba13 )

by Baptiste

created 2017-05-21 08:27 UTC

Map B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	435
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	13

Test Coverage

Coverage

98.34%

Importance

Changes

Metric	Value
wmc	48
lcom	1
cbo	13
dl	0
loc	435
ccs	178
cts	181
cp	0.9834
rs	8.4864
c	0
b	0
f	0

30 Methods

Rating	Name	Size	Complexity
A	__construct()	10	1
A	keyType()	4	1
A	valueType()	4	1
A	size()	4	1
A	count()	4	1
A	current()	4	1
A	key()	4	1
A	next()	6	1
A	rewind()	6	1
A	valid()	4	1
A	offsetExists()	4	1
A	offsetGet()	4	1
A	offsetSet()	4	1
A	offsetUnset()	4	1
B	put()	25	2
A	get()	10	2
A	contains()	4	1
A	clear()	9	1
A	equals()	8	2
A	filter()	14	3
A	foreach()	8	2
A	keys()	11	1
A	values()	11	1
A	map()	23	3
A	join()	4	1
A	remove()	23	2
A	partition()	22	3
A	reduce()	8	2
B	groupBy()	39	5
A	merge()	18	3

How to fix Complexity

<?php
declare(strict_types = 1);

namespace Innmind\Immutable;

use Innmind\Immutable\{
    Exception\InvalidArgumentException,
    Exception\LogicException,
    Exception\ElementNotFoundException,
    Exception\GroupEmptyMapException
};

final class Map implements MapInterface
{
    use Type;

    private $keyType;
    private $valueType;
    private $keySpecification;
    private $valueSpecification;
    private $keys;
    private $values;
    private $pairs;

    /**
     * {@inheritdoc}
     */
    public function __construct(string $keyType, string $valueType)
    {
        $this->keySpecification = $this->getSpecificationFor($keyType);
        $this->valueSpecification = $this->getSpecificationFor($valueType);
        $this->keyType = new Str($keyType);
        $this->valueType = new Str($valueType);
        $this->keys = new Stream($keyType);
        $this->values = new Stream($valueType);
        $this->pairs = new Stream(Pair::class);
    }

    /**
     * {@inheritdoc}
     */
    public function keyType(): Str
    {
        return $this->keyType;
    }

    /**
     * {@inheritdoc}
     */
    public function valueType(): Str
    {
        return $this->valueType;
    }

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

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

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

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

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

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

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

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

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

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

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

    /**
     * {@inheritdoc}
     */
    public function put($key, $value): MapInterface
    {
        $this->keySpecification->validate($key);
        $this->valueSpecification->validate($value);

        $map = clone $this;

        if ($this->keys->contains($key)) {
            $index = $this->keys->indexOf($key);
            $map->values = (new Stream((string) $this->valueType))
                ->append($this->values->take($index))
                ->add($value)
                ->append($this->values->drop($index + 1));
            $map->pairs = (new Stream(Pair::class))
                ->append($this->pairs->take($index))
                ->add(new Pair($key, $value))
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                ->append($this->pairs->drop($index + 1));
        } else {
            $map->keys = $this->keys->add($key);
            $map->values = $this->values->add($value);
            $map->pairs = $this->pairs->add(new Pair($key, $value));
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }

        return $map;
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 get($key)
    {
        if (!$this->keys->contains($key)) {
            throw new ElementNotFoundException;
        }

        return $this->values->get(
            $this->keys->indexOf($key)
        );
    }

    /**
     * {@inheritdoc}
     */
    public function contains($key): bool
    {
        return $this->keys->contains($key);
    }

    /**
     * {@inheritdoc}
     */
    public function clear(): MapInterface
    {
        $map = clone $this;
        $map->keys = new Stream((string) $this->keyType);
        $map->values = new Stream((string) $this->valueType);
        $map->pairs = new Stream(Pair::class);

        return $map;
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 equals(MapInterface $map): bool
    {
        if (!$map->keys()->equals($this->keys())) {
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            return false;
        }

        return $map->values()->equals($this->values());
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * {@inheritdoc}
     */
    public function filter(callable $predicate): MapInterface
    {
        $map = $this->clear();

        foreach ($this->pairs as $pair) {
            if ($predicate($pair->key(), $pair->value()) === true) {
                $map->keys = $map->keys->add($pair->key());
                $map->values = $map->values->add($pair->value());
                $map->pairs = $map->pairs->add($pair);
            }
        }

        return $map;
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 foreach(callable $function): MapInterface
    {
        foreach ($this->pairs as $pair) {
            $function($pair->key(), $pair->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 groupBy(callable $discriminator): MapInterface
    {
        if ($this->size() === 0) {
            throw new GroupEmptyMapException;
        }

        $map = null;

        foreach ($this->pairs as $pair) {
            $key = $discriminator($pair->key(), $pair->value());

            if ($map === null) {
                $map = new self(
                    $this->determineType($key),
                    MapInterface::class
                );
            }

            if ($map->contains($key)) {
                $map = $map->put(
                    $key,
                    $map->get($key)->put(
                        $pair->key(),
                        $pair->value()
                    )
                );
            } else {
                $map = $map->put(
                    $key,
                    $this->clear()->put(
                        $pair->key(),
                        $pair->value()
                    )
                );
            }
        }

        return $map;
    }

    /**
     * {@inheritdoc}
     */
    public function keys(): SetInterface
    {
        return $this
            ->keys
            ->reduce(
                new Set((string) $this->keyType),
                function(Set $carry, $key): Set {
                    return $carry->add($key);
                }
            );
    }

    /**
     * {@inheritdoc}
     */
    public function values(): StreamInterface
    {
        return $this
            ->values
            ->reduce(
                new Stream((string) $this->valueType),
                function(Stream $carry, $value): Stream {
                    return $carry->add($value);
                }
            );
    }

    /**
     * {@inheritdoc}
     */
    public function map(callable $function): MapInterface
    {
        $map = $this->clear();

        foreach ($this->pairs as $pair) {
            $return = $function(
                $pair->key(),
                $pair->value()
            );

            if ($return instanceof Pair) {
                $key = $return->key();
                $value = $return->value();
            } else {
                $key = $pair->key();
                $value = $return;
            }

            $map = $map->put($key, $value);
        }

        return $map;
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): Str
    {
        return $this->values->join($separator);
    }

    /**
     * {@inheritdoc}
     */
    public function remove($key): MapInterface
    {
        if (!$this->contains($key)) {
            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());
}
        }

        $index = $this->keys->indexOf($key);
        $map = clone $this;
        $map->keys = $this
            ->keys
            ->slice(0, $index)
            ->append($this->keys->slice($index + 1, $this->keys->size()));
        $map->values = $this
            ->values
            ->slice(0, $index)
            ->append($this->values->slice($index + 1, $this->values->size()));
        $map->pairs = $this
            ->pairs
            ->slice(0, $index)
            ->append($this->pairs->slice($index + 1, $this->pairs->size()));

        return $map;
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 merge(MapInterface $map): MapInterface
    {
        if (
            !$this->keyType()->equals($map->keyType()) ||
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            !$this->valueType()->equals($map->valueType())
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        ) {
            throw new InvalidArgumentException(
                'The 2 maps does not reference the same types'
            );
        }

        return $map->reduce(
            $this,
            function(self $carry, $key, $value): self {
                return $carry->put($key, $value);
            }
        );
    }

    /**
     * {@inheritdoc}
     */
    public function partition(callable $predicate): MapInterface
    {
        $truthy = $this->clear();
        $falsy = $this->clear();

        foreach ($this->pairs as $pair) {
            $return = $predicate(
                $pair->key(),
                $pair->value()
            );

            if ($return === true) {
                $truthy = $truthy->put($pair->key(), $pair->value());
            } else {
                $falsy = $falsy->put($pair->key(), $pair->value());
            }
        }

        return (new self('bool', MapInterface::class))
            ->put(true, $truthy)
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            ->put(false, $falsy);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * {@inheritdoc}
     */
    public function reduce($carry, callable $reducer)
    {
        foreach ($this->pairs as $pair) {
            $carry = $reducer($carry, $pair->key(), $pair->value());
        }

        return $carry;
    }
}


GitHub Access Token became invalid

Push — develop ( 5a4bbb...3fba13 )

Map B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

30 Methods

How to fix Complexity

Complex Class

1		<?php
2		declare(strict_types = 1);
3
4		namespace Innmind\Immutable;
5
6		use Innmind\Immutable\{
7		Exception\InvalidArgumentException,
8		Exception\LogicException,
9		Exception\ElementNotFoundException,
10		Exception\GroupEmptyMapException
11		};
12
13		final class Map implements MapInterface
14		{
15		use Type;
16
17		private $keyType;
18		private $valueType;
19		private $keySpecification;
20		private $valueSpecification;
21		private $keys;
22		private $values;
23		private $pairs;
24
25		/**
26		* {@inheritdoc}
27		*/
28	80	public function __construct(string $keyType, string $valueType)
29		{
30	80	$this->keySpecification = $this->getSpecificationFor($keyType);
31	80	$this->valueSpecification = $this->getSpecificationFor($valueType);
32	80	$this->keyType = new Str($keyType);
33	80	$this->valueType = new Str($valueType);
34	80	$this->keys = new Stream($keyType);
35	80	$this->values = new Stream($valueType);
36	80	$this->pairs = new Stream(Pair::class);
37	80	}
38
39		/**
40		* {@inheritdoc}

Innmind / Immutable

GitHub Access Token became invalid

Push — develop ( 5a4bbb...3fba13 )

Map B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

30 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like