Cycle\Schema\Table\ColumnSchema

Complexity

Total Complexity

27

Size/Duplication

Total Lines	179
Duplicated Lines	0 %

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getDefault()	0	7	2
A	getType()	0	3	1
A	render()	0	23	5
A	castDefault()	0	21	6
A	hasOption()	0	3	1
A	parse()	0	15	3
A	getName()	0	3	1
A	isNullable()	0	7	4
A	hasDefault()	0	7	2
A	isPrimary()	0	3	2

<?php
declare(strict_types=1);
/**
 * Spiral Framework.
 *
 * @license   MIT
 * @author    Anton Titov (Wolfy-J)
 */

namespace Cycle\Schema\Table;

use Cycle\Schema\Definition\Field;
use Cycle\Schema\Exception\ColumnException;
use Spiral\Database\Schema\AbstractColumn;

/**
 * Carries information about column definition.
 *
 * @internal
 */
final class ColumnSchema
{
    // default column value
    public const OPT_DEFAULT = 'default';

    // column can automatically define default value
    public const OPT_CAST_DEFAULT = 'castDefault';

    // column can be nullable
    public const OPT_NULLABLE = 'nullable';

    // provides ability to define complex types using string notation, i.e. string(32)
    private const DEFINITION = '/(?P<type>[a-z]+)(?: *\((?P<options>[^\)]+)\))?/i';

    /** @var Field */
    private $field;

    /** @var string */
    private $type;

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

    /**
     * @return string
     */
    public function getName(): string
    {
        return $this->field->getColumn();
    }

    /**
     * Get column type.
     *
     * @return string
     */
    public function getType(): string
    {
        return $this->type;
    }

    /**
     * @return bool
     */
    public function isPrimary(): bool
    {
        return $this->field->isPrimary() || in_array($this->type, ['primary', 'bigPrimary']);
    }

    /**
     * @return bool
     */
    public function isNullable(): bool
    {
        if ($this->hasDefault() && $this->getDefault() === null) {
            return true;
        }

        return $this->hasOption(self::OPT_NULLABLE) && !$this->isPrimary();
    }

    /**
     * @return bool
     */
    public function hasDefault(): bool
    {
        if ($this->isPrimary()) {
            return false;
        }

        return $this->hasOption(self::OPT_DEFAULT);
    }

    /**
     * @return mixed
     *
     * @throws ColumnException
     */
    public function getDefault()
    {
        if (!$this->hasDefault()) {
            throw new ColumnException("No default value on `{$this->field->getColumn()}`");
        }

        return $this->field->getOptions()->get(self::OPT_DEFAULT);
    }

    /**
     * Render column definition.
     *
     * @param AbstractColumn $column
     *
     * @throws ColumnException
     */
    public function render(AbstractColumn $column)
    {
        $column->nullable($this->isNullable());

        try {
            // bypassing call to AbstractColumn->__call method (or specialized column method)
            call_user_func_array([$column, $this->type], $this->typeOptions);
        } catch (\Throwable $e) {
            throw new ColumnException(
                "Invalid column type definition in '{$column->getTable()}'.'{$column->getName()}'",
                $e->getCode(),
                $e
            );
        }

        if ($this->hasDefault() && $this->getDefault() !== null) {
            $column->defaultValue($this->getDefault());
            return;
        }

        if ($this->hasOption(self::OPT_CAST_DEFAULT)) {
            // cast default value
            $column->defaultValue($this->castDefault($column));
        }
    }

    /**
     * @param AbstractColumn $column
     * @return bool|float|int|string
     */
    private function castDefault(AbstractColumn $column)
    {
        if (in_array($column->getAbstractType(), ['timestamp', 'datetime', 'time', 'date'])) {
            return 0;
        }

        if ($column->getAbstractType() == 'enum') {
            // we can use first enum value as default
            return $column->getEnumValues()[0];
        }

        switch ($column->getType()) {
            case AbstractColumn::INT:
                return 0;
            case AbstractColumn::FLOAT:
                return 0.0;
            case AbstractColumn::BOOL:
                return false;
        }

        return '';
    }

    /**
     * @param string $option
     * @return bool
     */
    private function hasOption(string $option): bool
    {
        return $this->field->getOptions()->has($option);
    }

    /**
     * Parse field definition into table definition.
     *
     * @param Field $field
     * @return ColumnSchema
     *
     * @throws ColumnException
     */
    public static function parse(Field $field): self
    {
        $column = new ColumnSchema();
        $column->field = $field;

        if (!preg_match(self::DEFINITION, $field->getType(), $type)) {
            throw new ColumnException("Invalid column type definition in `{$field->getType()}`");
        }

        $column->type = $type['type'];
        if (!empty($type['options'])) {
            $column->typeOptions = array_map('trim', explode(',', $type['options'] ?? ''));
        }

        return $column;
    }
}