Innmind\Compose\Visualization\Node\Element

Complexity

Total Complexity

14

Size/Duplication

Total Lines	109
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	attributes()	0	3	1
A	name()	0	3	1
A	hasAttributes()	0	3	1
A	shaped()	0	3	1
A	target()	0	3	1
A	linkedTo()	0	3	1
A	build()	0	4	1
A	edges()	0	3	1
A	displayAs()	0	3	1
A	dependency()	0	15	1
A	argument()	0	11	1
A	service()	0	18	2

<?php
declare(strict_types = 1);

namespace Innmind\Compose\Visualization\Node;

use Innmind\Compose\Definition\{
    Name as ServiceName,
    Service,
    Service\Constructor,
    Argument
};
use Innmind\Graphviz\{
    Node,
    Edge,
    Node\Name,
    Node\Shape
};
use Innmind\Url\UrlInterface;
use Innmind\Colour\RGBA;
use Innmind\Immutable\{
    MapInterface,
    SetInterface,
    Str
};

final class Element implements Node
{
    private $node;

    private function __construct(Node $node)
    {
        $this->node = $node;
    }

    public static function dependency(
        ServiceName $dependency,
        ServiceName $name,
        Constructor $constructor
    ): self {
        $constructor = Str::of((string) $constructor)->replace('\\', '\\\\');

        $node = self::build($dependency->add($name));
        $node->displayAs(
            (string) Str::of((string) $name)->append(
                '\n('.$constructor.')'
            )
        );

        return new self($node);
    }

    public static function service(Service $service): self
    {
        $constructor = Str::of((string) $service->constructor())->replace('\\', '\\\\');

        $node = self::build($service->name());
        $node->displayAs(
            (string) Str::of((string) $service->name())->append(
                '\n('.$constructor.')'
            )
        );

        if ($service->exposed()) {
            $node->shaped(
                Shape::house()->fillWithColor(RGBA::fromString('#0f0'))
            );
        }

        return new self($node);
    }

    public static function argument(Argument $argument): self
    {
        $type = Str::of((string) $argument->type())->replace('\\', '\\\\');

        $node = self::build($argument->name());
        $node->displayAs(
            (string) Str::of((string) $argument->name())
                ->append('\n('.$type.')')
        );

        return new self($node);
    }

    public static function build(ServiceName $name): Node
    {
        return Node\Node::named(
            (string) Str::of((string) $name)->replace('.', '_')
        );
    }

    public function name(): Name
    {
        return $this->node->name();
    }

    /**
     * {@inheritdoc}
     */
    public function edges(): SetInterface
    {
        return $this->node->edges();
    }

    public function linkedTo(Node $node): Edge
    {
        return $this->node->linkedTo($node);
    }

    public function target(UrlInterface $url): Node
    {
        return $this->node->target($url);
    }
    public function displayAs(string $label): Node
    {
        return $this->node->displayAs($label);
    }

    public function shaped(Shape $shape): Node
    {
        return $this->node->shaped($shape);
    }

    public function hasAttributes(): bool
    {
        return $this->node->hasAttributes();
    }

    /**
     * {@inheritdoc}
     */
    public function attributes(): MapInterface
    {
        return $this->node->attributes();
    }
}