Graviton\GeneratorBundle\Definition\JsonDefinitionField

Complexity

Total Complexity

13

Size/Duplication

Total Lines	187
Duplicated Lines	7.49 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

72.84%

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getDef()	0	4	1
A	getName()	0	4	1
A	getTypeDoctrine()	0	9	2
A	getType()	0	4	1
A	getTypeSerializer()	0	9	2
A	getXDynamicKey()	0	7	2
A	getExposedName()	0	6	2
B	getDefAsArray()	14	39	1

<?php
namespace Graviton\GeneratorBundle\Definition;

use Graviton\DocumentBundle\Entity\ExtReference;
use Graviton\DocumentBundle\Entity\Hash;
use Graviton\GeneratorBundle\Definition\Schema\XDynamicKey;

/**
 * A single field as specified in the json definition
 *
 * @author   List of contributors <https://github.com/libgraviton/graviton/graphs/contributors>
 * @license  http://opensource.org/licenses/gpl-license.php GNU Public License
 * @link     http://swisscom.ch
 */
class JsonDefinitionField implements DefinitionElementInterface
{
    /**
     * Typemap from our source types to doctrine types
     */
    private static $doctrineTypeMap = [
        self::TYPE_STRING => 'string',
        self::TYPE_VARCHAR => 'string',
        self::TYPE_TEXT => 'string',
        self::TYPE_INTEGER => 'int',
        self::TYPE_LONG => 'int',
        self::TYPE_FLOAT => 'float',
        self::TYPE_DOUBLE => 'float',
        self::TYPE_DECIMAL => 'float',
        self::TYPE_DATETIME => 'date',
        self::TYPE_BOOLEAN => 'boolean',
        self::TYPE_OBJECT => 'hash',
        self::TYPE_EXTREF => 'extref',
    ];

    private static $serializerTypeMap = [
        self::TYPE_STRING => 'string',
        self::TYPE_VARCHAR => 'string',
        self::TYPE_TEXT => 'string',
        self::TYPE_INTEGER => 'integer',
        self::TYPE_LONG => 'integer',
        self::TYPE_FLOAT => 'double',
        self::TYPE_DOUBLE => 'double',
        self::TYPE_DECIMAL => 'double',
        self::TYPE_DATETIME => 'DateTime',
        self::TYPE_BOOLEAN => 'boolean',
        self::TYPE_OBJECT => Hash::class,
        self::TYPE_EXTREF => ExtReference::class,
    ];

    /**
     * @var string
     */
    private $name;
    /**
     * Our definition
     *
     * @var Schema\Field
     */
    private $definition;

    /**
     * Constructor
     *
     * @param string       $name       Field name
     * @param Schema\Field $definition Definition
     */
    public function __construct($name, Schema\Field $definition)
    {
        $this->name = $name;
        $this->definition = $definition;
    }

    /**
     * Returns the field definition
     *
     * @return Schema\Field definition
     */
    public function getDef()
    {
        return $this->definition;
    }

    /**
     * Returns the field name
     *
     * @return string Name
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * Returns the whole definition in array form
     *
     * @return array Definition

Consider making the return type a bit more specific; maybe use array<string,integer|string|boolean|array|XDynamicKey|null>.

     */
    public function getDefAsArray()
    {
        return [
            'length'            => $this->definition->getLength(),
            'title'             => $this->definition->getTitle(),
            'description'       => $this->definition->getDescription(),
            'readOnly'          => $this->definition->getReadOnly(),
            'required'          => $this->definition->getRequired(),
            'searchable'        => $this->definition->getSearchable(),
            'translatable'      => $this->definition->getTranslatable(),
            'collection'        => $this->definition->getCollection(),

            'name'              => $this->getName(),
            'type'              => $this->getType(),
            'exposedName'       => $this->getExposedName(),
            'doctrineType'      => $this->getTypeDoctrine(),
            'serializerType'    => $this->getTypeSerializer(),
            'xDynamicKey'       => $this->getXDynamicKey(),
            'relType'           => null,
            'isClassType'       => false,
            'constraints'       => array_map(
                function (Schema\Constraint $constraint) {

This code seems to be duplicated across your project.

                    return [
                        'name'  => $constraint->getName(),
                        'options'   => array_map(
                            function (Schema\ConstraintOption $option) {
                                return [
                                    'name'  => $option->getName(),
                                    'value' => $option->getValue(),
                                ];
                            },
                            $constraint->getOptions()
                        )
                    ];
                },
                $this->definition->getConstraints()
            )
        ];
    }

    /**
     * Returns the field type in a doctrine-understandable way..
     *
     * @return string Type
     */
    public function getTypeDoctrine()
    {
        if (isset(self::$doctrineTypeMap[$this->getType()])) {
            return self::$doctrineTypeMap[$this->getType()];
        }

        // our fallback default
        return self::$doctrineTypeMap[self::TYPE_STRING];
    }

    /**
     * Returns the field type
     *
     * @return string Type
     */
    public function getType()
    {
        return strtolower($this->definition->getType());
    }

    /**
     * Returns the field type in a serializer-understandable way..
     *
     * @return string Type
     */
    public function getTypeSerializer()
    {
        if (isset(self::$serializerTypeMap[$this->getType()])) {
            return self::$serializerTypeMap[$this->getType()];
        }

        // our fallback default
        return self::$serializerTypeMap[self::TYPE_STRING];
    }

    /**
     * @return XDynamicKey|void
     */
    public function getXDynamicKey()
    {
        $key = $this->definition->getXDynamicKey();
        if ($key instanceof XDynamicKey) {
            return $key;
        }
    }

    /**
     * Gets the name this field should be exposed as (serializer concern).
     * Normally this is the name, but can be overriden by "exposeAs" property on the field.
     *
     * @return string exposed field name
     */
    private function getExposedName()
    {
        return $this->definition->getExposeAs() === null ?
            $this->getName() :
            $this->definition->getExposeAs();
    }
}