Elao\Enum\Bridge\Doctrine\DBAL\Types\TypesDumper

Complexity

Total Complexity

18

Size/Duplication

Total Lines	157
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	dumpToFile()	0	4	1
A	dump()	0	34	4
B	getTypeCode()	0	67	7
A	valueAsCode()	0	16	5
A	getTypeClassname()	0	6	1

<?php

/*
 * This file is part of the "elao/enum" package.
 *
 * Copyright (C) Elao
 *
 * @author Elao <contact@elao.com>
 */

namespace Elao\Enum\Bridge\Doctrine\DBAL\Types;

use Elao\Enum\Exception\LogicException;

/**
 * @internal
 */
class TypesDumper
{
    public const TYPE_INT = 'int';
    public const TYPE_STRING = 'string';
    public const TYPE_ENUM = 'enum';
    public const TYPE_JSON_COLLECTION = 'json_collection';
    public const TYPE_CSV_COLLECTION = 'csv_collection';
    public const TYPES = [
        self::TYPE_INT,
        self::TYPE_STRING,
        self::TYPE_ENUM,
        self::TYPE_JSON_COLLECTION,
        self::TYPE_CSV_COLLECTION,
    ];

    public const TYPES_SUFFIXES = [
        self::TYPE_INT => 'Type',
        self::TYPE_STRING => 'Type',
        self::TYPE_ENUM => 'Type',
        self::TYPE_JSON_COLLECTION => 'JsonCollectionType',
        self::TYPE_CSV_COLLECTION => 'CsvCollectionType',
    ];

    public const MARKER = 'ELAO_ENUM_DT';

    public function dumpToFile(string $file, array $types)
    {
        file_put_contents($file, $this->dump($types));
    }

    private function dump(array $types): string
    {
        $namespaces = [];
        foreach ($types as [$enumClass, $type, $name, $default]) {
            $fqcn = self::getTypeClassname($enumClass, $type);

The variable $enumClass does not exist. Did you forget to declare it?

The variable $type does not exist. Did you forget to declare it?

            $classname = basename(str_replace('\\', '/', $fqcn));
            $ns = substr($fqcn, 0, -\strlen($classname) - 1);

            if (!isset($namespaces[$ns])) {
                $namespaces[$ns] = '';
            }

            $namespaces[$ns] .= $this->getTypeCode(
                $classname,
                $enumClass,
                $type,
                $name,

The variable $name does not exist. Did you forget to declare it?

                $default

The variable $default does not exist. Did you forget to declare it?

            );
        }

        $code = "<?php\n";
        foreach ($namespaces as $namespace => $typeCode) {
            $code .= <<<PHP

namespace $namespace {
$typeCode
}

PHP;
        }

        return $code;
    }

    private function getTypeCode(
        string $classname,
        string $enumClass,
        string $type,
        string $name,
        $defaultOnNull
    ): string {
        $code = <<<PHP
            public const NAME = '$name';

            protected function getEnumClass(): string
            {
                return \\{$enumClass}::class;
            }

            public function getName(): string
            {
                return static::NAME;
            }
PHP;
        switch ($type) {
            case self::TYPE_INT:
                $baseClass = AbstractIntegerEnumType::class;
                break;
            case self::TYPE_STRING:
                $baseClass = AbstractEnumType::class;

                if ($defaultOnNull !== null) {
                    $defaultOnNullCode = $this->valueAsCode($defaultOnNull);
                    $code .= <<<PHP

            protected function onNullFromDatabase()
            {
                return \\{$enumClass}::get({$defaultOnNullCode});
            }

            protected function onNullFromPhp()
            {
                return {$defaultOnNullCode};
            }
PHP;
                }
                break;
            case self::TYPE_ENUM:
                $baseClass = AbstractEnumSQLDeclarationType::class;
                break;
            case self::TYPE_JSON_COLLECTION:
                $baseClass = AbstractJsonCollectionEnumType::class;
                break;
            case self::TYPE_CSV_COLLECTION:
                $baseClass = AbstractCsvCollectionEnumType::class;
                break;
            default:
                throw new LogicException(sprintf('Unexpected type "%s"', $type));
        }

        return <<<PHP

    if (!\class_exists($classname::class)) {
        class $classname extends \\{$baseClass}
        {
$code
        }
    }

PHP;
    }

    private function valueAsCode($value): string
    {
        if (is_string($value)) {
            if (strpos($value, '::') !== false) { // Constant name
                return sprintf('\\%s', ltrim($value, '\\'));
            }

            return sprintf('\'%s\'', $value); // plain string
        }

        if (is_bool($value)) {
            return $value ? 'true': 'false';
        }

        return (string)$value;
    }

    public static function getTypeClassname(string $class, string $type): string
    {
        $suffix = self::TYPES_SUFFIXES[$type];

        return self::MARKER . "\\{$class}{$suffix}";
    }
}