MappingHelper::backticks() - Code Metrics - Inspection of "Improving Code Coverage, Default Values for fields" - edmondscommerce/doctrine-static-meta - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#51)

by joseph

created 2018-05-17 15:55 UTC

MappingHelper::backticks() A

↳ Parent: MappingHelper

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	3
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
cc	1
eloc	1
nc	1
nop	1
crap	1

<?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\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_DECIMAL  = 'string';
    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_DECIMAL,
        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_DECIMAL,
        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.'`';
    }

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

edmondscommerce / doctrine-static-meta

GitHub Access Token became invalid

Pull Request — master (#51)

MappingHelper::backticks() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like