MappingHelper::getType() - Code Metrics - Inspection of "Improving code coverage 3" - edmondscommerce/doctrine-static-meta - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#54)

by joseph

created 2018-06-04 13:55 UTC

MappingHelper::getType() A

↳ Parent: MappingHelper

Complexity

Conditions	2
Paths	2

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	8
ccs	5
cts	5
cp	1
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	4
nc	2
nop	1
crap	2

<?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
{

    /**
     * @see https://stackoverflow.com/a/34275878
     */
    public const DATETIME_DEFAULT_CURRENT_TIME_STAMP = 0;

    /**
     * Quick accessors for common types that are supported by methods in this helper
     */
    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;

    /**
     * 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,
    ];

    /**
     * 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,
    ];

    /**
     * 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)
                // see https://github.com/symfony/symfony-docs/issues/639
                // basically, if we are using utf8mb4 then the max col
                // length on strings is no longer 255.
                ->length(190)
                ->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
            && self::DATETIME_DEFAULT_CURRENT_TIME_STAMP !== $default
        ) {
            throw new \InvalidArgumentException(
                'Invalid default '.$default
                .' This must be one of:'
                ."\n - null"
                ."\n - \EdmondsCommerce\DoctrineStaticMeta\MappingHelper::DATETIME_DEFAULT_CURRENT_TIME_STAMP"
            );
        }
        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();
        }
    }

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

edmondscommerce / doctrine-static-meta

GitHub Access Token became invalid

Pull Request — master (#54)

MappingHelper::getType() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like