PhUml\Parser\Definitions

Complexity

Total Complexity

16

Size/Duplication

Total Lines	99
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	addClass()	0	8	1
A	addExternalInterface()	0	3	1
A	all()	0	3	1
A	get()	0	3	1
A	add()	0	6	3
A	addInterface()	0	6	1
A	parent()	0	3	1
A	isInterface()	0	3	1
A	has()	0	3	1
A	interfaces()	0	3	1
A	isClass()	0	3	1
A	addExternalClass()	0	3	1
A	hasParent()	0	3	1

<?php
/**
 * PHP version 7.1
 *
 * This source file is subject to the license that is bundled with this package in the file LICENSE.
 */
namespace PhUml\Parser;

class Definitions
{
    private static $classDefaults = [
        'attributes' => [],
        'functions' => [],
        'implements' => [],
        'extends' => null,
    ];

    private static $interfaceDefaults = [
        'functions' => [],
        'extends' => null,
    ];

    /** @var array */
    private $definitions;

    public function __construct()
    {
        $this->definitions = [];
    }

    public function add(array $definition): void
    {
        if ($this->isClass($definition)) {
            $this->addClass($definition);
        } elseif ($this->isInterface($definition)) {
            $this->addInterface($definition);
        }
    }

    public function get(string $name)
    {
        return $this->definitions[$name] ?? null;
    }

    public function addExternalClass(string $name): void
    {
        $this->definitions[$name] = array_merge(['class' => $name], self::$classDefaults);
    }

    public function addExternalInterface(string $name): void
    {
        $this->definitions[$name] = array_merge(['interface' => $name], self::$interfaceDefaults);
    }

    public function has(string $definitionName): bool
    {
        return isset($this->definitions[$definitionName]);
    }

    public function all(): array
    {
        return $this->definitions;
    }

    /** @return string[] */
    public function interfaces(array $definition): array
    {
        return $definition['implements'];
    }

    public function hasParent(array $definition): bool
    {
        return isset($definition['extends']);
    }

    public function parent(array $definition): ?string
    {
        return $definition['extends'] ?? null;
    }

    public function isClass(array $definition): bool
    {
        return isset($definition['class']);
    }

    public function isInterface(array $definition): bool
    {
        return isset($definition['interface']);
    }

    private function addClass(array $definition): void
    {
        $this->definitions[$definition['class']] = [
            'class' => $definition['class'],
            'attributes' => $definition['attributes'] ?? self::$classDefaults['attributes'],
            'functions' => $definition['functions'] ?? self::$classDefaults['functions'],
            'implements' => $definition['implements'] ?? self::$classDefaults['implements'],
            'extends' => $definition['extends'] ?? self::$classDefaults['extends'],
        ];
    }

    private function addInterface(array $definition): void
    {
        $this->definitions[$definition['interface']] = [
            'interface' => $definition['interface'],
            'functions' => $definition['functions'] ?? self::$interfaceDefaults['functions'],
            'extends' => $definition['extends'] ?? self::$interfaceDefaults['extends'],
        ];
    }
}