PhUml\Parser\Raw\RawDefinition

Complexity

Total Complexity

14

Size/Duplication

Total Lines	100
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	name()	0	3	1
A	attributes()	0	3	1
A	constants()	0	3	1
A	methods()	0	3	1
A	__construct()	0	3	1
A	parent()	0	3	1
A	externalInterface()	0	3	1
A	isClass()	0	3	1
A	interface()	0	7	1
A	class()	0	9	1
A	interfaces()	0	3	1
A	externalClass()	0	3	1
A	hasParent()	0	3	1
A	isInterface()	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\Raw;

/**
 * A raw definition is a wrapper for an associative array of strings used to build `Definition`s
 *
 * @see \PhUml\Parser\Raw\Builders\RawClassBuilder To check how a `RawDefinition` for a class is built
 * @see \PhUml\Parser\Raw\Builders\RawInterfaceBuilder To check how a `RawDefinition` for an interface is built
 */
class RawDefinition
{
    private static $classDefaults = [
        'attributes' => [],
        'constants' => [],
        'methods' => [],
        'implements' => [],
        'extends' => null,
    ];

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

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

    private function __construct(array $definition)
    {
        $this->definition = $definition;
    }

    public static function class(array $definition): RawDefinition

Possible parse error: non-abstract method defined as abstract

    {
        return new RawDefinition([
            'class' => $definition['class'],
            'constants' => $definition['constants'] ?? self::$classDefaults['constants'],
            'attributes' => $definition['attributes'] ?? self::$classDefaults['attributes'],
            'methods' => $definition['methods'] ?? self::$classDefaults['methods'],
            'implements' => $definition['implements'] ?? self::$classDefaults['implements'],
            'extends' => $definition['extends'] ?? self::$classDefaults['extends'],
        ]);
    }

    public static function interface(array $definition): RawDefinition

Possible parse error: non-abstract method defined as abstract

    {
        return new RawDefinition([
            'interface' => $definition['interface'],
            'constants' => $definition['constants'] ?? self::$interfaceDefaults['constants'],
            'methods' => $definition['methods'] ?? self::$interfaceDefaults['methods'],
            'extends' => $definition['extends'] ?? self::$interfaceDefaults['extends'],
        ]);
    }

    public static function externalClass(string $name): RawDefinition
    {
        return new RawDefinition(array_merge(['class' => $name], self::$classDefaults));
    }

    public static function externalInterface(string $name): RawDefinition
    {
        return new RawDefinition(array_merge(['interface' => $name], self::$interfaceDefaults));
    }

    public function name(): string
    {
        return $this->definition['class'] ?? $this->definition['interface'];
    }

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

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

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

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

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

    public function attributes(): array
    {
        return $this->definition['attributes'];
    }

    public function methods(): array
    {
        return $this->definition['methods'];
    }

    public function constants(): array
    {
        return $this->definition['constants'];
    }
}