EventSauce\EventSourcing\CodeGeneration\DefinitionGroup

Complexity

Total Complexity

22

Size/Duplication

Total Lines	186
Duplicated Lines	0 %

Coupling/Cohesion

Components	6
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes

0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	create()	0	4	1
A	withNamespace()	0	6	1
A	typeSerializer()	0	6	1
A	serializerForType()	0	6	1
A	typeDeserializer()	0	4	1
A	deserializerForType()	0	6	1
A	fieldSerializer()	0	4	1
A	serializerForField()	0	4	1
A	fieldDeserializer()	0	4	1
A	deserializerForField()	0	4	1
A	fieldDefault()	0	5	1
A	aliasType()	0	4	1
A	resolveTypeAlias()	0	8	2
A	event()	0	4	1
A	command()	0	4	1
A	typeForField()	0	4	1
A	exampleForField()	0	4	1
A	events()	0	4	1
A	commands()	0	4	1
A	namespace()	0	4	1

<?php

namespace EventSauce\EventSourcing\CodeGeneration;

use EventSauce\EventSourcing\PointInTime;

final class DefinitionGroup
{
    /**
     * @var string
     */
    private $namespace;

    /**
     * @var EventDefinition[]
     */
    private $events = [];

    /**
     * @var array
     */
    private $defaults = [];

    /**
     * @var array <type, template>
     */
    private $typeSerializer = [
        'string' => '({type}) {param}',
        'array' => '({type}) {param}',
        'integer' => '({type}) {param}',
        'int' => '({type}) {param}',
        'bool' => '({type}) {param}',
        'float' => '({type}) {param}',
    ];

    /**
     * @var array <type, template>
     */
    private $typeDeserializer = [
        'string' => '({type}) {param}',
        'array' => '({type}) {param}',
        'integer' => '({type}) {param}',
        'int' => '({type}) {param}',
        'bool' => '({type}) {param}',
        'float' => '({type}) {param}',
    ];

    /**
     * @var array <field, template>
     */
    private $fieldSerializer = [];

    /**
     * @var array <field, template>
     */
    private $fieldDeserializer = [];

    /**
     * @var CommandDefinition[]
     */
    private $commands = [];

    /**
     * @var string[]
     */
    private $typeAliases = [];

    public function __construct()
    {
        $this->typeSerializer(PointInTime::class, '{param}->toString()');
        $this->typeDeserializer(PointInTime::class, '{type}::fromString({param})');
    }

    public static function create(string $namespace): DefinitionGroup
    {
        return (new DefinitionGroup())->withNamespace($namespace);
    }

    public function withNamespace(string $namespace): DefinitionGroup
    {
        $this->namespace = $namespace;

        return $this;
    }

    public function typeSerializer(string $type, string $template)
    {
        $type = $this->resolveTypeAlias($type);

        $this->typeSerializer[TypeNormalizer::normalize($type)] = $template;
    }

    public function serializerForType($type)
    {
        $type = $this->resolveTypeAlias($type);

        return $this->typeSerializer[$type] ?? "new {type}({param})";
    }

    public function typeDeserializer(string $type, string $template)
    {
        $this->typeDeserializer[TypeNormalizer::normalize($type)] = $template;
    }

    public function deserializerForType($type)
    {
        $type = $this->resolveTypeAlias($type);

        return $this->typeDeserializer[$type] ?? "new {type}({param})";
    }

    public function fieldSerializer(string $field, string $template)
    {
        $this->fieldSerializer[$field] = $template;
    }

    public function serializerForField($field)
    {
        return $this->fieldSerializer[$field] ?? null;
    }

    public function fieldDeserializer(string $field, string $template)
    {
        $this->fieldDeserializer[$field] = $template;
    }

    public function deserializerForField($field)
    {
        return $this->fieldDeserializer[$field] ?? null;
    }

    public function fieldDefault(string $name, string $type, string $example = null)
    {
        $type = $this->resolveTypeAlias($type);
        $this->defaults[$name] = compact('type', 'example');
    }

    public function aliasType(string $alias, string $type)
    {
        $this->typeAliases[$alias] = TypeNormalizer::normalize($type);
    }

    public function resolveTypeAlias(string $alias = null)
    {
        while (isset($this->typeAliases[$alias])) {
            $alias = $this->typeAliases[$alias];
        }

        return $alias;
    }

    public function event(string $name): EventDefinition
    {
        return $this->events[] = new EventDefinition($this, $name);
    }

    public function command(string $name)
    {
        return $this->commands[] = new CommandDefinition($this, $name);
    }

    public function typeForField(string $field): string
    {
        return $this->defaults[$field]['type'] ?? 'string';
    }

    public function exampleForField(string $field)
    {
        return $this->defaults[$field]['example'] ?? null;
    }

    /**
     * @return EventDefinition[]
     */
    public function events(): array
    {
        return $this->events;
    }

    /**
     * @return CommandDefinition[]
     */
    public function commands(): array
    {
        return $this->commands;
    }

    public function namespace(): string

Possible parse error: non-abstract method defined as abstract

    {
        return $this->namespace;

The visibility should be declared for property $this.

    }
}