MappingHelper::setSimpleIntegerFields() - Code Metrics - Inspection of "Tidying standard library and rebuilding example" - edmondscommerce/doctrine-static-meta - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#59)

by joseph

created 2018-06-25 14:28 UTC

MappingHelper::setSimpleIntegerFields() A

↳ Parent: MappingHelper

Complexity

Conditions	4
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	15
CRAP Score	4

Importance

Changes

Metric	Value
dl	0
loc	26
rs	9.504
c	0
b	0
f	0
ccs	15
cts	15
cp	1
cc	4
nc	3
nop	4
crap	4

<?php declare(strict_types=1);

namespace EdmondsCommerce\DoctrineStaticMeta;

use Doctrine\Common\Util\Inflector;
use Doctrine\DBAL\Types\Type;
use Doctrine\ORM\Mapping\Builder\ClassMetadataBuilder;
use Doctrine\ORM\Mapping\Builder\FieldBuilder;
use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\NamespaceHelper;
use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\TypeHelper;
use EdmondsCommerce\DoctrineStaticMeta\Schema\Database;

/**
 * Class MappingHelper
 *
 * Helper functions to assist with setting up Doctrine mapping meta data
 *
 * @package EdmondsCommerce\DoctrineStaticMeta
 *
 * @SuppressWarnings(PHPMD.StaticAccess)
 */
class MappingHelper
{
    /**
     * Quick accessors for common types that are supported by methods in this helper
     *
     * Note this is not all of the types supported by Doctrine
     */
    public const TYPE_STRING   = Type::STRING;
    public const TYPE_DATETIME = Type::DATETIME;
    public const TYPE_FLOAT    = Type::FLOAT;
    public const TYPE_DECIMAL  = Type::DECIMAL;
    public const TYPE_INTEGER  = Type::INTEGER;
    public const TYPE_TEXT     = Type::TEXT;
    public const TYPE_BOOLEAN  = Type::BOOLEAN;
    public const TYPE_JSON     = Type::JSON;

    /**
     * This is the list of common types, listed above
     */
    public const COMMON_TYPES = [
        self::TYPE_STRING,
        self::TYPE_DATETIME,
        self::TYPE_FLOAT,
        self::TYPE_DECIMAL,
        self::TYPE_INTEGER,
        self::TYPE_TEXT,
        self::TYPE_BOOLEAN,
        self::TYPE_JSON,
    ];

    /**
     * Which types do we support marking as unique
     */
    public const UNIQUEABLE_TYPES = [
        self::TYPE_STRING,
        self::TYPE_INTEGER,
    ];

    public const PHP_TYPE_STRING   = 'string';
    public const PHP_TYPE_DATETIME = '\\'.\DateTime::class;
    public const PHP_TYPE_FLOAT    = 'float';
    public const PHP_TYPE_INTEGER  = 'int';
    public const PHP_TYPE_TEXT     = 'string';
    public const PHP_TYPE_BOOLEAN  = 'bool';

    public const PHP_TYPES = [
        self::PHP_TYPE_STRING,
        self::PHP_TYPE_DATETIME,
        self::PHP_TYPE_FLOAT,
        self::PHP_TYPE_INTEGER,
        self::PHP_TYPE_TEXT,
        self::PHP_TYPE_BOOLEAN,
    ];

    /**
     * The PHP type associated with the mapping type
     */
    public const COMMON_TYPES_TO_PHP_TYPES = [
        self::TYPE_STRING   => self::PHP_TYPE_STRING,
        self::TYPE_DATETIME => self::PHP_TYPE_DATETIME,
        self::TYPE_FLOAT    => self::PHP_TYPE_FLOAT,
        self::TYPE_DECIMAL  => self::PHP_TYPE_STRING,
        self::TYPE_INTEGER  => self::PHP_TYPE_INTEGER,
        self::TYPE_TEXT     => self::PHP_TYPE_TEXT,
        self::TYPE_BOOLEAN  => self::PHP_TYPE_BOOLEAN,
        self::TYPE_JSON     => self::PHP_TYPE_STRING,
    ];

    /**
     * This is the full list of mapping types
     *
     * @see \Doctrine\DBAL\Types\Type
     */
    public const ALL_DBAL_TYPES = [
        Type::TARRAY,
        Type::SIMPLE_ARRAY,
        Type::JSON,
        Type::BIGINT,
        Type::BOOLEAN,
        Type::DATETIME,
        Type::DATETIME_IMMUTABLE,
        Type::DATETIMETZ,
        Type::DATETIMETZ_IMMUTABLE,
        Type::DATE,
        Type::DATE_IMMUTABLE,
        Type::TIME,
        Type::TIME_IMMUTABLE,
        Type::DECIMAL,
        Type::INTEGER,
        Type::OBJECT,
        Type::SMALLINT,
        Type::STRING,
        Type::TEXT,
        Type::BINARY,
        Type::BLOB,
        Type::FLOAT,
        Type::GUID,
        Type::DATEINTERVAL,
    ];

    public const MIXED_TYPES = [
        // Doctrine hydrates decimal values as strings.
        // However, setting these using an int or float is also valid.
        Type::DECIMAL,
    ];

    /**
     * @param string $entityFqn
     *
     * @return string
     */
    public static function getPluralForFqn(string $entityFqn): string
    {
        $singular = self::getSingularForFqn($entityFqn);

        return Inflector::pluralize($singular);
    }

    /**
     * @param string $entityFqn
     *
     * @return string
     */
    public static function getSingularForFqn(string $entityFqn): string
    {
        $shortName = self::getShortNameForFqn($entityFqn);

        return lcfirst(Inflector::singularize($shortName));
    }

    /**
     * @param string $entityFqn
     *
     * @return string
     */
    public static function getShortNameForFqn(string $entityFqn): string
    {
        return substr($entityFqn, strrpos($entityFqn, '\\') + 1);
    }

    /**
     * Get the properly backticked and formatted column name for a field
     *
     * @param string $field
     *
     * @return string
     */
    public static function getColumnNameForField(string $field): string
    {
        return self::backticks(Inflector::tableize($field));
    }

    /**
     * @param string $entityFqn
     *
     * @return string
     */
    public static function getTableNameForEntityFqn(
        string $entityFqn
    ): string {
        $namespaceHelper = new NamespaceHelper();
        $subFqn          = $namespaceHelper->getEntitySubNamespace(
            $entityFqn
        );
        $tableName       = \str_replace('\\', '', $subFqn);
        $tableName       = self::backticks(Inflector::tableize($tableName));
        if (\strlen($tableName) > Database::MAX_IDENTIFIER_LENGTH) {
            $tableName = substr($tableName, -Database::MAX_IDENTIFIER_LENGTH);
        }

        return $tableName;
    }

    /**
     * Wrap the name in backticks
     *
     * @param string $name
     *
     * @return string
     */
    public static function backticks(string $name): string
    {
        return '`'.$name.'`';
    }

    private static function getType($var): string
    {
        static $typeHelper;
        if (null === $typeHelper) {
            $typeHelper = new TypeHelper();
        }

        return $typeHelper->getType($var);
    }

    /**
     * Set bog standard string fields quickly in bulk
     *
     * @param array                $fields
     * @param ClassMetadataBuilder $builder
     * @param mixed                $default
     * @param bool                 $isUnique
     * In this case the boolean argument is simply data
     * @SuppressWarnings(PHPMD.BooleanArgumentFlag)
     */
    public static function setSimpleStringFields(
        array $fields,
        ClassMetadataBuilder $builder,
        $default = null,
        bool $isUnique = false
    ): void {
        if (null !== $default && !\is_string($default)) {
            throw new \InvalidArgumentException(
                'Invalid default value '.$default
                .' with type '.self::getType($default)
            );
        }
        foreach ($fields as $field) {
            $fieldBuilder = new FieldBuilder(
                $builder,
                [
                    'fieldName' => $field,
                    'type'      => Type::STRING,
                    'default'   => $default,
                ]
            );
            $fieldBuilder
                ->columnName(self::getColumnNameForField($field))
                ->nullable(null === $default)
                ->unique($isUnique)
                ->length(Database::MAX_VARCHAR_LENGTH)
                ->build();
        }
    }

    /**
     * Set bog standard text fields quickly in bulk
     *
     * @param array                $fields
     * @param ClassMetadataBuilder $builder
     * @param mixed                $default
     * In this case the boolean argument is simply data
     * @SuppressWarnings(PHPMD.BooleanArgumentFlag)
     */
    public static function setSimpleTextFields(
        array $fields,
        ClassMetadataBuilder $builder,
        $default = null
    ): void {
        if (null !== $default && !\is_string($default)) {
            throw new \InvalidArgumentException(
                'Invalid default value '.$default
                .' with type '.self::getType($default)
            );
        }
        foreach ($fields as $field) {
            $fieldBuilder = new FieldBuilder(
                $builder,
                [
                    'fieldName' => $field,
                    'type'      => Type::TEXT,
                    'default'   => $default,
                ]
            );
            $fieldBuilder->columnName(self::getColumnNameForField($field))
                         ->nullable(null === $default)
                         ->build();
        }
    }


    /**
     * Set bog standard float fields quickly in bulk
     *
     * @param array                $fields
     * @param ClassMetadataBuilder $builder
     * @param mixed                $default
     * In this case the boolean argument is simply data
     * @SuppressWarnings(PHPMD.BooleanArgumentFlag)
     */
    public static function setSimpleFloatFields(
        array $fields,
        ClassMetadataBuilder $builder,
        $default = null
    ): void {
        if (null !== $default && !\is_float($default)) {
            throw new \InvalidArgumentException(
                'Invalid default value '.$default
                .' with type '.self::getType($default)
            );
        }
        foreach ($fields as $field) {
            $fieldBuilder = new FieldBuilder(
                $builder,
                [
                    'fieldName' => $field,
                    'type'      => Type::FLOAT,
                    'default'   => $default,
                ]
            );
            $fieldBuilder
                ->columnName(self::getColumnNameForField($field))
                ->nullable(null === $default)
                ->build();
        }
    }

    /**
     * Set bog standard decimal fields quickly in bulk
     *
     * @param array                $fields
     * @param ClassMetadataBuilder $builder
     * @param mixed                $default
     * In this case the boolean argument is simply data
     * @SuppressWarnings(PHPMD.BooleanArgumentFlag)
     */
    public static function setSimpleDecimalFields(
        array $fields,
        ClassMetadataBuilder $builder,
        $default = null
    ): void {
        if (null !== $default && !\is_string($default)) {
            throw new \InvalidArgumentException(
                'Invalid default value '.$default
                .' with type '.self::getType($default)
            );
        }
        if (null !== $default && !is_numeric($default)) {
            throw new \InvalidArgumentException(
                'Invalid default value '.$default
                .', even though it is a string, it must be numeric '
            );
        }
        foreach ($fields as $field) {
            $fieldBuilder = new FieldBuilder(
                $builder,
                [
                    'fieldName' => $field,
                    'type'      => Type::DECIMAL,
                    'default'   => (string)(float)$default,
                ]
            );
            $fieldBuilder
                ->columnName(self::getColumnNameForField($field))
                ->nullable(null === $default)
                ->precision(Database::MAX_DECIMAL_PRECISION)
                ->scale(Database::MAX_DECIMAL_SCALE)
                ->build();
        }
    }

    /**
     * Set bog standard dateTime fields quickly in bulk
     *
     * @param array                $fields
     * @param ClassMetadataBuilder $builder
     * @param mixed                $default
     * In this case the boolean argument is simply data
     * @SuppressWarnings(PHPMD.BooleanArgumentFlag)
     */
    public static function setSimpleDatetimeFields(
        array $fields,
        ClassMetadataBuilder $builder,
        $default = null
    ): void {
        if (null !== $default) {
            throw new \InvalidArgumentException('DateTime currently only support null as a default value');
        }
        foreach ($fields as $field) {
            $fieldBuilder = new FieldBuilder(
                $builder,
                [
                    'fieldName' => $field,
                    'type'      => Type::DATETIME,
                    'default'   => $default,
                ]
            );
            $fieldBuilder
                ->columnName(self::getColumnNameForField($field))
                ->nullable(null === $default)
                ->build();
        }
    }

    /**
     * Set bog standard integer fields quickly in bulk
     *
     * @param array                $fields
     * @param ClassMetadataBuilder $builder
     * @param mixed                $default
     * @param bool                 $isUnique
     * In this case the boolean argument is simply data
     * @SuppressWarnings(PHPMD.BooleanArgumentFlag)
     */
    public static function setSimpleIntegerFields(
        array $fields,
        ClassMetadataBuilder $builder,
        $default = null,
        bool $isUnique = false
    ): void {
        if (null !== $default && !\is_int($default)) {
            throw new \InvalidArgumentException(
                'Invalid default value '.$default
                .' with type '.self::getType($default)
            );
        }
        foreach ($fields as $field) {
            $fieldBuilder = new FieldBuilder(
                $builder,
                [
                    'fieldName' => $field,
                    'type'      => Type::INTEGER,
                    'default'   => $default,
                ]
            );
            $fieldBuilder
                ->columnName(self::getColumnNameForField($field))
                ->nullable(null === $default)
                ->unique($isUnique)
                ->build();
        }
    }

    /**
     * Set bog standard boolean fields quickly in bulk
     *
     * @param array                $fields
     * @param ClassMetadataBuilder $builder
     * @param mixed                $default
     * In this case the boolean argument is simply data
     * @SuppressWarnings(PHPMD.BooleanArgumentFlag)
     */
    public static function setSimpleBooleanFields(
        array $fields,
        ClassMetadataBuilder $builder,
        $default = null
    ): void {
        if (null !== $default && !\is_bool($default)) {
            throw new \InvalidArgumentException(
                'Invalid default value '.$default
                .' with type '.self::getType($default)
            );
        }
        foreach ($fields as $field) {
            $fieldBuilder = new FieldBuilder(
                $builder,
                [
                    'fieldName' => $field,
                    'type'      => Type::BOOLEAN,
                    'default'   => $default,
                ]
            );
            $fieldBuilder
                ->columnName(self::getColumnNameForField($field))
                ->nullable(null === $default)
                ->build();
        }
    }

    /**
     * Create JSON fields
     *
     * Will use real JSON in the DB engine if it is supported
     *
     * This should be used for any structured data, arrays, lists, simple objects
     *
     * @param array                $fields
     * @param ClassMetadataBuilder $builder
     * @param null                 $default

     */
    public static function setSimpleJsonFields(
        array $fields,
        ClassMetadataBuilder $builder,
        $default = null
    ) {
        if (null !== $default && !\is_string($default)) {
            throw new \InvalidArgumentException(
                'Invalid default value '.$default
                .' with type '.self::getType($default)
            );
        }
        foreach ($fields as $field) {
            $fieldBuilder = new FieldBuilder(
                $builder,
                [
                    'fieldName' => $field,
                    'type'      => Type::JSON,
                    'default'   => $default,
                ]
            );
            $fieldBuilder
                ->columnName(self::getColumnNameForField($field))
                ->nullable(null === $default)
                ->build();
        }
    }

    /**
     * Bulk create multiple fields of different simple types
     *
     * Always creates nullable fields, if you want to set a default, you must call the type based method
     *
     * @param array                $fieldToType [
     *                                          'fieldName'=>'fieldSimpleType'
     *                                          ]
     * @param ClassMetadataBuilder $builder
     */
    public static function setSimpleFields(
        array $fieldToType,
        ClassMetadataBuilder $builder
    ): void {
        foreach ($fieldToType as $field => $type) {
            $method = "setSimple$type".'fields';
            static::$method([$field], $builder);
        }
    }
}


1		<?php declare(strict_types=1);
2
3		namespace EdmondsCommerce\DoctrineStaticMeta;
4
5		use Doctrine\Common\Util\Inflector;
6		use Doctrine\DBAL\Types\Type;
7		use Doctrine\ORM\Mapping\Builder\ClassMetadataBuilder;
8		use Doctrine\ORM\Mapping\Builder\FieldBuilder;
9		use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\NamespaceHelper;
10		use EdmondsCommerce\DoctrineStaticMeta\CodeGeneration\TypeHelper;
11		use EdmondsCommerce\DoctrineStaticMeta\Schema\Database;
12
13		/**
14		* Class MappingHelper
15		*
16		* Helper functions to assist with setting up Doctrine mapping meta data
17		*
18		* @package EdmondsCommerce\DoctrineStaticMeta
19		*
20		* @SuppressWarnings(PHPMD.StaticAccess)
21		*/
22		class MappingHelper
23		{
24		/**
25		* Quick accessors for common types that are supported by methods in this helper
26		*
27		* Note this is not all of the types supported by Doctrine
28		*/
29		public const TYPE_STRING = Type::STRING;
30		public const TYPE_DATETIME = Type::DATETIME;
31		public const TYPE_FLOAT = Type::FLOAT;
32		public const TYPE_DECIMAL = Type::DECIMAL;
33		public const TYPE_INTEGER = Type::INTEGER;
34		public const TYPE_TEXT = Type::TEXT;
35		public const TYPE_BOOLEAN = Type::BOOLEAN;
36		public const TYPE_JSON = Type::JSON;
37
38		/**
39		* This is the list of common types, listed above
40		*/
41		public const COMMON_TYPES = [
42		self::TYPE_STRING,
43		self::TYPE_DATETIME,
44		self::TYPE_FLOAT,
45		self::TYPE_DECIMAL,
46		self::TYPE_INTEGER,
47		self::TYPE_TEXT,
48		self::TYPE_BOOLEAN,
49		self::TYPE_JSON,
50		];
51
52		/**
53		* Which types do we support marking as unique
54		*/
55		public const UNIQUEABLE_TYPES = [
56		self::TYPE_STRING,
57		self::TYPE_INTEGER,
58		];
59
60		public const PHP_TYPE_STRING = 'string';
61		public const PHP_TYPE_DATETIME = '\\'.\DateTime::class;
62		public const PHP_TYPE_FLOAT = 'float';
63		public const PHP_TYPE_INTEGER = 'int';
64		public const PHP_TYPE_TEXT = 'string';
65		public const PHP_TYPE_BOOLEAN = 'bool';
66
67		public const PHP_TYPES = [
68		self::PHP_TYPE_STRING,
69		self::PHP_TYPE_DATETIME,
70		self::PHP_TYPE_FLOAT,
71		self::PHP_TYPE_INTEGER,
72		self::PHP_TYPE_TEXT,
73		self::PHP_TYPE_BOOLEAN,
74		];
75
76		/**
77		* The PHP type associated with the mapping type
78		*/
79		public const COMMON_TYPES_TO_PHP_TYPES = [
80		self::TYPE_STRING => self::PHP_TYPE_STRING,
81		self::TYPE_DATETIME => self::PHP_TYPE_DATETIME,
82		self::TYPE_FLOAT => self::PHP_TYPE_FLOAT,
83		self::TYPE_DECIMAL => self::PHP_TYPE_STRING,
84		self::TYPE_INTEGER => self::PHP_TYPE_INTEGER,
85		self::TYPE_TEXT => self::PHP_TYPE_TEXT,
86		self::TYPE_BOOLEAN => self::PHP_TYPE_BOOLEAN,
87		self::TYPE_JSON => self::PHP_TYPE_STRING,
88		];
89
90		/**
91		* This is the full list of mapping types
92		*
93		* @see \Doctrine\DBAL\Types\Type
94		*/
95		public const ALL_DBAL_TYPES = [
96		Type::TARRAY,
97		Type::SIMPLE_ARRAY,
98		Type::JSON,
99		Type::BIGINT,
100		Type::BOOLEAN,
101		Type::DATETIME,
102		Type::DATETIME_IMMUTABLE,
103		Type::DATETIMETZ,
104		Type::DATETIMETZ_IMMUTABLE,
105		Type::DATE,
106		Type::DATE_IMMUTABLE,
107		Type::TIME,
108		Type::TIME_IMMUTABLE,
109		Type::DECIMAL,
110		Type::INTEGER,
111		Type::OBJECT,
112		Type::SMALLINT,
113		Type::STRING,
114		Type::TEXT,
115		Type::BINARY,
116		Type::BLOB,
117		Type::FLOAT,
118		Type::GUID,
119		Type::DATEINTERVAL,
120		];
121
122		public const MIXED_TYPES = [
123		// Doctrine hydrates decimal values as strings.
124		// However, setting these using an int or float is also valid.
125		Type::DECIMAL,
126		];
127
128		/**
129		* @param string $entityFqn
130		*
131		* @return string
132		*/
133	120	public static function getPluralForFqn(string $entityFqn): string
134		{
135	120	$singular = self::getSingularForFqn($entityFqn);
136
137	120	return Inflector::pluralize($singular);
138		}
139
140		/**
141		* @param string $entityFqn
142		*
143		* @return string
144		*/
145	120	public static function getSingularForFqn(string $entityFqn): string
146		{
147	120	$shortName = self::getShortNameForFqn($entityFqn);
148
149	120	return lcfirst(Inflector::singularize($shortName));
150		}
151
152		/**
153		* @param string $entityFqn
154		*
155		* @return string
156		*/
157	120	public static function getShortNameForFqn(string $entityFqn): string
158		{
159	120	return substr($entityFqn, strrpos($entityFqn, '\\') + 1);
160		}
161
162		/**
163		* Get the properly backticked and formatted column name for a field
164		*
165		* @param string $field
166		*
167		* @return string
168		*/
169	40	public static function getColumnNameForField(string $field): string
170		{
171	40	return self::backticks(Inflector::tableize($field));
172		}
173
174		/**
175		* @param string $entityFqn
176		*
177		* @return string
178		*/
179	46	public static function getTableNameForEntityFqn(
180		string $entityFqn
181		): string {
182	46	$namespaceHelper = new NamespaceHelper();
183	46	$subFqn = $namespaceHelper->getEntitySubNamespace(
184	46	$entityFqn
185		);
186	46	$tableName = \str_replace('\\', '', $subFqn);
187	46	$tableName = self::backticks(Inflector::tableize($tableName));
188	46	if (\strlen($tableName) > Database::MAX_IDENTIFIER_LENGTH) {
189		$tableName = substr($tableName, -Database::MAX_IDENTIFIER_LENGTH);
190		}
191
192	46	return $tableName;
193		}
194
195		/**
196		* Wrap the name in backticks
197		*
198		* @param string $name
199		*
200		* @return string
201		*/
202	47	public static function backticks(string $name): string
203		{
204	47	return '`'.$name.'`';
205		}
206
207	5	private static function getType($var): string
208		{
209	5	static $typeHelper;
210	5	if (null === $typeHelper) {
211	1	$typeHelper = new TypeHelper();
212		}
213
214	5	return $typeHelper->getType($var);
215		}
216
217		/**
218		* Set bog standard string fields quickly in bulk
219		*
220		* @param array $fields
221		* @param ClassMetadataBuilder $builder
222		* @param mixed $default
223		* @param bool $isUnique
224		* In this case the boolean argument is simply data
225		* @SuppressWarnings(PHPMD.BooleanArgumentFlag)
226		*/
227	28	public static function setSimpleStringFields(
228		array $fields,
229		ClassMetadataBuilder $builder,
230		$default = null,
231		bool $isUnique = false
232		): void {
233	28	if (null !== $default && !\is_string($default)) {
234	1	throw new \InvalidArgumentException(
235	1	'Invalid default value '.$default
236	1	.' with type '.self::getType($default)
237		);
238		}
239	27	foreach ($fields as $field) {
240	27	$fieldBuilder = new FieldBuilder(
241	27	$builder,
242		[
243	27	'fieldName' => $field,
244	27	'type' => Type::STRING,
245	27	'default' => $default,
246		]
247		);
248		$fieldBuilder
249	27	->columnName(self::getColumnNameForField($field))
250	27	->nullable(null === $default)
251	27	->unique($isUnique)
252	27	->length(Database::MAX_VARCHAR_LENGTH)
253	27	->build();
254		}
255	27	}
256
257		/**
258		* Set bog standard text fields quickly in bulk
259		*
260		* @param array $fields
261		* @param ClassMetadataBuilder $builder
262		* @param mixed $default
263		* In this case the boolean argument is simply data
264		* @SuppressWarnings(PHPMD.BooleanArgumentFlag)
265		*/
266	14	public static function setSimpleTextFields(
267		array $fields,
268		ClassMetadataBuilder $builder,
269		$default = null
270		): void {
271	14	if (null !== $default && !\is_string($default)) {
272	1	throw new \InvalidArgumentException(
273	1	'Invalid default value '.$default
274	1	.' with type '.self::getType($default)
275		);
276		}
277	13	foreach ($fields as $field) {
278	13	$fieldBuilder = new FieldBuilder(
279	13	$builder,
280		[
281	13	'fieldName' => $field,
282	13	'type' => Type::TEXT,
283	13	'default' => $default,
284		]
285		);
286	13	$fieldBuilder->columnName(self::getColumnNameForField($field))
287	13	->nullable(null === $default)
288	13	->build();
289		}
290	13	}
291
292
293		/**
294		* Set bog standard float fields quickly in bulk
295		*
296		* @param array $fields
297		* @param ClassMetadataBuilder $builder
298		* @param mixed $default
299		* In this case the boolean argument is simply data
300		* @SuppressWarnings(PHPMD.BooleanArgumentFlag)
301		*/
302	14	public static function setSimpleFloatFields(
303		array $fields,
304		ClassMetadataBuilder $builder,
305		$default = null
306		): void {
307	14	if (null !== $default && !\is_float($default)) {
308	1	throw new \InvalidArgumentException(
309	1	'Invalid default value '.$default
310	1	.' with type '.self::getType($default)
311		);
312		}
313	13	foreach ($fields as $field) {
314	13	$fieldBuilder = new FieldBuilder(
315	13	$builder,
316		[
317	13	'fieldName' => $field,
318	13	'type' => Type::FLOAT,
319	13	'default' => $default,
320		]
321		);
322		$fieldBuilder
323	13	->columnName(self::getColumnNameForField($field))
324	13	->nullable(null === $default)
325	13	->build();
326		}
327	13	}
328
329		/**
330		* Set bog standard decimal fields quickly in bulk
331		*
332		* @param array $fields
333		* @param ClassMetadataBuilder $builder
334		* @param mixed $default
335		* In this case the boolean argument is simply data
336		* @SuppressWarnings(PHPMD.BooleanArgumentFlag)
337		*/
338	14	public static function setSimpleDecimalFields(
339		array $fields,
340		ClassMetadataBuilder $builder,
341		$default = null
342		): void {
343	14	if (null !== $default && !\is_string($default)) {
344		throw new \InvalidArgumentException(
345		'Invalid default value '.$default
346		.' with type '.self::getType($default)
347		);
348		}
349	14	if (null !== $default && !is_numeric($default)) {
350	1	throw new \InvalidArgumentException(
351	1	'Invalid default value '.$default
352	1	.', even though it is a string, it must be numeric '
353		);
354		}
355	13	foreach ($fields as $field) {
356	13	$fieldBuilder = new FieldBuilder(
357	13	$builder,
358		[
359	13	'fieldName' => $field,
360	13	'type' => Type::DECIMAL,
361	13	'default' => (string)(float)$default,
362		]
363		);
364		$fieldBuilder
365	13	->columnName(self::getColumnNameForField($field))
366	13	->nullable(null === $default)
367	13	->precision(Database::MAX_DECIMAL_PRECISION)
368	13	->scale(Database::MAX_DECIMAL_SCALE)
369	13	->build();
370		}
371	13	}
372
373		/**
374		* Set bog standard dateTime fields quickly in bulk
375		*
376		* @param array $fields
377		* @param ClassMetadataBuilder $builder
378		* @param mixed $default
379		* In this case the boolean argument is simply data
380		* @SuppressWarnings(PHPMD.BooleanArgumentFlag)
381		*/
382	15	public static function setSimpleDatetimeFields(
383		array $fields,
384		ClassMetadataBuilder $builder,
385		$default = null
386		): void {
387	15	if (null !== $default) {
388	1	throw new \InvalidArgumentException('DateTime currently only support null as a default value');
389		}
390	14	foreach ($fields as $field) {
391	14	$fieldBuilder = new FieldBuilder(
392	14	$builder,
393		[
394	14	'fieldName' => $field,
395	14	'type' => Type::DATETIME,
396	14	'default' => $default,
397		]
398		);
399		$fieldBuilder
400	14	->columnName(self::getColumnNameForField($field))
401	14	->nullable(null === $default)
402	14	->build();
403		}
404	14	}
405
406		/**
407		* Set bog standard integer fields quickly in bulk
408		*
409		* @param array $fields
410		* @param ClassMetadataBuilder $builder
411		* @param mixed $default
412		* @param bool $isUnique
413		* In this case the boolean argument is simply data
414		* @SuppressWarnings(PHPMD.BooleanArgumentFlag)
415		*/
416	14	public static function setSimpleIntegerFields(
417		array $fields,
418		ClassMetadataBuilder $builder,
419		$default = null,
420		bool $isUnique = false
421		): void {
422	14	if (null !== $default && !\is_int($default)) {
423	1	throw new \InvalidArgumentException(
424	1	'Invalid default value '.$default
425	1	.' with type '.self::getType($default)
426		);
427		}
428	13	foreach ($fields as $field) {
429	13	$fieldBuilder = new FieldBuilder(
430	13	$builder,
431		[
432	13	'fieldName' => $field,
433	13	'type' => Type::INTEGER,
434	13	'default' => $default,
435		]
436		);
437		$fieldBuilder
438	13	->columnName(self::getColumnNameForField($field))
439	13	->nullable(null === $default)
440	13	->unique($isUnique)
441	13	->build();
442		}
443	13	}
444
445		/**
446		* Set bog standard boolean fields quickly in bulk
447		*
448		* @param array $fields
449		* @param ClassMetadataBuilder $builder
450		* @param mixed $default
451		* In this case the boolean argument is simply data
452		* @SuppressWarnings(PHPMD.BooleanArgumentFlag)
453		*/
454	17	public static function setSimpleBooleanFields(
455		array $fields,
456		ClassMetadataBuilder $builder,
457		$default = null
458		): void {
459	17	if (null !== $default && !\is_bool($default)) {
460	1	throw new \InvalidArgumentException(
461	1	'Invalid default value '.$default
462	1	.' with type '.self::getType($default)
463		);
464		}
465	16	foreach ($fields as $field) {
466	16	$fieldBuilder = new FieldBuilder(
467	16	$builder,
468		[
469	16	'fieldName' => $field,
470	16	'type' => Type::BOOLEAN,
471	16	'default' => $default,
472		]
473		);
474		$fieldBuilder
475	16	->columnName(self::getColumnNameForField($field))
476	16	->nullable(null === $default)
477	16	->build();
478		}
479	16	}
480
481		/**
482		* Create JSON fields
483		*
484		* Will use real JSON in the DB engine if it is supported
485		*
486		* This should be used for any structured data, arrays, lists, simple objects
487		*
488		* @param array $fields
489		* @param ClassMetadataBuilder $builder
490		* @param null $default
		0 ignored issues – show Documentation Bug introduced 2018-06-20 20:00 UTC by Report Bug Copy Issue Report Are you sure the doc-type for parameter `$default` is correct as it would always require `null` to be passed? Loading history...
491		*/
492	14	public static function setSimpleJsonFields(
493		array $fields,
494		ClassMetadataBuilder $builder,
495		$default = null
496		) {
497	14	if (null !== $default && !\is_string($default)) {
498		throw new \InvalidArgumentException(
499		'Invalid default value '.$default
500		.' with type '.self::getType($default)
501		);
502		}
503	14	foreach ($fields as $field) {
504	14	$fieldBuilder = new FieldBuilder(
505	14	$builder,
506		[
507	14	'fieldName' => $field,
508	14	'type' => Type::JSON,
509	14	'default' => $default,
510		]
511		);
512		$fieldBuilder
513	14	->columnName(self::getColumnNameForField($field))
514	14	->nullable(null === $default)
515	14	->build();
516		}
517	14	}
518
519		/**
520		* Bulk create multiple fields of different simple types
521		*
522		* Always creates nullable fields, if you want to set a default, you must call the type based method
523		*
524		* @param array $fieldToType [
525		* 'fieldName'=>'fieldSimpleType'
526		* ]
527		* @param ClassMetadataBuilder $builder
528		*/
529	3	public static function setSimpleFields(
530		array $fieldToType,
531		ClassMetadataBuilder $builder
532		): void {
533	3	foreach ($fieldToType as $field => $type) {
534	3	$method = "setSimple$type".'fields';
535	3	static::$method([$field], $builder);
536		}
537	3	}
538		}
539

edmondscommerce / doctrine-static-meta

GitHub Access Token became invalid

Pull Request — master (#59)

MappingHelper::setSimpleIntegerFields() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like