Cerbero\Enum\Services\Generator

Complexity

Total Complexity

10

Size/Duplication

Total Lines	79
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	3
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	formatCases()	0	15	3
A	replacements()	0	7	2
A	stub()	0	3	1
A	__construct()	0	3	1
A	generate()	0	12	3

<?php

declare(strict_types=1);

namespace Cerbero\Enum\Services;

use Cerbero\Enum\Data\GeneratingEnum;
use Cerbero\Enum\Enums\Backed;

use function Cerbero\Enum\ensureParentDirectory;

/**
 * The enums generator.
 */
class Generator
{
    /**
     * The enum being generated.
     */
    protected GeneratingEnum $enum;

    /**
     * Instantiate the class.
     *
     * @param class-string<\UnitEnum> $namespace

The doc comment class-string<\UnitEnum> at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string<\UnitEnum>.

     * @param string[] $cases
     * @throws \ValueError
     */
    public function __construct(string $namespace, array $cases, ?string $backed = null)
    {
        $this->enum = new GeneratingEnum($namespace, Backed::backCases($cases, $backed));
    }

    /**
     * Generate the given enum.
     */
    public function generate(bool $overwrite = false): bool
    {
        if ($this->enum->exists && ! $overwrite) {
            return true;
        }

        ensureParentDirectory($this->enum->path);

        $stub = (string) file_get_contents($this->stub());
        $content = strtr($stub, $this->replacements());

        return file_put_contents($this->enum->path, $content) !== false;
    }

    /**
     * Retrieve the path of the stub.
     */
    protected function stub(): string
    {
        return __DIR__ . '/../../stubs/enum.stub';
    }

    /**
     * Retrieve the replacements for the placeholders.
     *
     * @return array<string, mixed>
     */
    protected function replacements(): array
    {
        return [
            '{{ name }}' => $this->enum->name,
            '{{ namespace }}' => $this->enum->namespace,
            '{{ backingType }}' => $this->enum->backingType ? ": {$this->enum->backingType}" : '',
            '{{ cases }}' => $this->formatCases($this->enum->cases),
        ];
    }

    /**
     * Retrieve the given cases formatted as a string
     *
     * @param array<string, string|int|null> $cases
     */
    protected function formatCases(array $cases): string
    {
        $formatted = [];

        foreach ($cases as $name => $value) {
            $formattedValue = match (true) {
                is_int($value), str_contains((string) $value, '<<') => " = {$value}",
                is_string($value) => ' = ' . (str_contains($value, "'") ? "\"{$value}\"" : "'{$value}'"),

It seems like $value can also be of type null; however, parameter $haystack of str_contains() does only seem to accept string, maybe add an additional type check?

                default => '',
            };

            $formatted[] = "    case {$name}{$formattedValue};";
        }

        return implode(PHP_EOL . PHP_EOL, $formatted);
    }
}