Graze\Morphism\Parse\ColumnDefinition::defaultValue()

Complexity

Conditions	35
Paths	36

Size

Total Lines	122
Code Lines	75

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	72
CRAP Score	35

Importance

Changes

0

<?php
    private function defaultValue(Token $token)
    {
        if ($token->eq(Token::IDENTIFIER, 'NULL')) {
            if (!$this->nullable) {
                throw new \Exception("Column type cannot have NULL default: $this->type");
            }
            return null;
        }

        if ($token->eq(Token::IDENTIFIER, 'CURRENT_TIMESTAMP')) {
            if (!in_array($this->type, ['timestamp', 'datetime'])) {
                throw new \Exception("Only 'timestamp' and 'datetime' types can have default value of CURRENT_TIMESTAMP");
            }
            return 'CURRENT_TIMESTAMP';
        }

        if (!in_array($token->type, [Token::STRING, Token::HEX, Token::BIN, Token::NUMBER])) {
            throw new \Exception("Invalid token type for default value: $token->type");
        }

        $typeInfo = $this->getTypeInfo();

        switch ($typeInfo->kind) {
            case 'bit':
                return $token->asNumber();

            case 'int':
                if ($this->zerofill) {
                    $length = $this->length;
                    return sprintf("%0{$length}d", $token->asNumber());
                } else {
                    return $token->asNumber();
                }
                // Comment to appease this phpcs rule:
                // PSR2.ControlStructures.SwitchDeclaration.TerminatingComment
                // There must be a comment when fall-through is intentional
                // in a non-empty case body

            case 'decimal':
                $decimals = is_null($this->decimals) ? 0 : $this->decimals;

The condition is_null($this->decimals) is always false.

                if ($this->zerofill) {
                    $length = $this->length;
                    return sprintf("%0{$length}.{$decimals}f", $token->asNumber());
                } else {
                    return sprintf("%.{$decimals}f", $token->asNumber());
                }
                // Comment to appease this phpcs rule:
                // PSR2.ControlStructures.SwitchDeclaration.TerminatingComment
                // There must be a comment when fall-through is intentional
                // in a non-empty case body

            case 'date':
                return $token->asDate();

            case 'time':
                return $token->asTime();

            case 'datetime':
                return $token->asDateTime();

            case 'year':
                $year = $token->asNumber();
                if ($token->type !== Token::STRING && $year == 0) {
                    return '0000';
                }
                if ($year < 70) {
                    return (string)round($year + 2000);
                } elseif ($year <= 99) {
                    return (string)round($year + 1900);
                } elseif (1901 <= $year && $year <= 2155) {
                    return (string)round($year);
                } else {
                    throw new \Exception("Invalid default year (1901-2155): $year");
                }
                // Comment to appease this phpcs rule:
                // PSR2.ControlStructures.SwitchDeclaration.TerminatingComment
                // There must be a comment when fall-through is intentional
                // in a non-empty case body

            case 'text':
                return $token->asString();

            case 'binary':
                return str_pad($token->asString(), $this->length, "\0");

            case 'enum':
                if ($token->type !== Token::STRING) {
                    throw new \Exception("Invalid data type for default enum value: $token->type");
                }
                foreach ($this->elements as $element) {
                    if (strtolower($token->text) === strtolower($element)) {
                        return $element;
                    }
                }
                throw new \Exception("Default enum value not found in enum: $token->text");

            case 'set':
                if ($token->type !== Token::STRING) {
                    throw new \Exception("Invalid type for default set value: $token->type");
                }
                if ($token->text === '') {
                    return '';
                }
                $defaults = explode(',', strtolower($token->text));
                foreach ($defaults as $default) {
                    $match = null;
                    foreach ($this->elements as $i => $element) {
                        if (strtolower($default) === strtolower($element)) {
                            $match = $i;
                            break;
                        }
                    }
                    if (is_null($match)) {
                        throw new \Exception("Default set value not found in set: $token->text");
                    }
                    $matches[$match] = $this->elements[$match];
                }
                ksort($matches, SORT_NUMERIC);
                return implode(',', $matches);

            default:
                throw new \Exception("This kind of data type cannot have a default value: $typeInfo->kind");
        }