Field::index() - Code Metrics - Inspection of "Adds a `mappingsFrom` function" - laravel-doctrine/fluent - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — alt-path-loader ( dd5973 )

by Guido

created 2017-07-04 21:40 UTC

Field::index() A

↳ Parent: Field

Complexity

Conditions	2
Paths	2

Size

Total Lines	15
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	8
nc	2
nop	1
dl	0
loc	15
rs	9.4285
c	0
b	0
f	0

<?php

namespace LaravelDoctrine\Fluent\Builders;

use BadMethodCallException;
use Doctrine\Common\Persistence\Mapping\ClassMetadata;
use Doctrine\DBAL\Types\Type;
use Doctrine\ORM\Mapping\Builder\ClassMetadataBuilder;
use Doctrine\ORM\Mapping\Builder\FieldBuilder;
use Doctrine\ORM\Mapping\ClassMetadataInfo;
use LaravelDoctrine\Fluent\Buildable;
use LaravelDoctrine\Fluent\Builders\Traits\Macroable;
use LaravelDoctrine\Fluent\Builders\Traits\Queueable;
use LaravelDoctrine\Fluent\Builders\Traits\QueuesMacros;
use LaravelDoctrine\Fluent\Extensions\ExtensibleClassMetadata;
use LaravelDoctrine\Fluent\Extensions\Gedmo\GedmoFieldHints;

/**
 * @method $this unique(boolean $flag = true)   Boolean value to determine if the value of the column should be unique
 *                                              across all rows of the underlying entities table.
 * @method $this nullable(boolean $flag = true) Determines if NULL values are allowed for this column.
 * @method $this length(int $length)            Used by the “string” type to determine its maximum length in the
 *                                              database. Doctrine does not validate the length of string values
 *                                              for you.
 * @method $this columnName(string $column)     By default the property name is used for the database column name also,
 *                                              however the ‘name’ attribute allows you to determine the column name.
 * @method $this precision(int $precision)      The precision for a decimal (exact numeric) column (applies only for
 *                                              decimal column), which is the maximum number of digits that are stored
 *                                              for the values.
 * @method $this scale(int $scale)              The scale for a decimal (exact numeric) column (applies only for
 *                                              decimal column), which represents the number of digits to the right of
 *                                              the decimal point and must not be greater than precision.
 * @method $this default(string $default)       The default value to set for the column if no value is supplied.
 * @method $this columnDefinition(string $def)  DDL SQL snippet that starts after the column name and specifies the
 *                                              complete (non-portable!) column definition. This attribute allows to
 *                                              make use of advanced RMDBS features. However you should make careful
 *                                              use of this feature and the consequences. SchemaTool will not detect
 *                                              changes on the column correctly anymore if you use “columnDefinition”.
 * @method $this option($name, $value)          Set custom options
 */
class Field implements Buildable
{
    use Macroable;
    use Queueable {
        build as buildQueued;
    }
    use QueuesMacros;
    use GedmoFieldHints;

    /**
     * @var FieldBuilder
     */
    protected $fieldBuilder;

    /**
     * @var ClassMetadataBuilder
     */
    protected $metaDatabuilder;

    /**
     * @var ClassMetadataInfo
     */
    protected $classMetadata;

    /**
     * @var Type
     */
    protected $type;

    /**
     * @var string
     */
    protected $name;

    /**
     * Protected constructor to force usage of factory method.
     *
     * @param FieldBuilder         $fieldBuilder
     * @param ClassMetadataBuilder $builder
     * @param Type                 $type
     * @param string               $name
     */
    protected function __construct(FieldBuilder $fieldBuilder, ClassMetadataBuilder $builder, Type $type, $name)
    {
        $this->fieldBuilder = $fieldBuilder;
        $this->metaDatabuilder = $builder;
        $this->classMetadata = $builder->getClassMetadata();
        $this->type = $type;
        $this->name = $name;
    }

    /**
     * @param ClassMetadataBuilder $builder
     * @param string               $type
     * @param string               $name
     *
     * @throws \Doctrine\DBAL\DBALException
     *
     * @return Field
     */
    public static function make(ClassMetadataBuilder $builder, $type, $name)
    {
        $type = Type::getType($type);

        $field = $builder->createField($name, $type->getName());

        return new static($field, $builder, $type, $name);
    }

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

    /**
     * @return Type
     */
    public function getType()
    {
        return $this->type;
    }

    /**
     * @return ClassMetadata|ExtensibleClassMetadata
     */
    public function getClassMetadata()
    {
        return $this->classMetadata;
    }

    /**
     * By default the property name is used for the database column name also, however the ‘name’ attribute
     * allows you to determine the column name.
     *
     * @param string $columnName
     *
     * @return $this
     */
    public function name($columnName)
    {
        $this->columnName($columnName);

        return $this;
    }

    /**
     * @return Field
     */
    public function autoIncrement()
    {
        $this->generatedValue();

        return $this;
    }

    /**
     * @param callable|null $callback
     *
     * @return Field
     */
    public function generatedValue(callable $callback = null)
    {
        $generatedValue = new GeneratedValue($this->fieldBuilder, $this->classMetadata);

        if ($callback) {
            $callback($generatedValue);
        }

        $generatedValue->build();

        return $this;
    }

    /**
     * Boolean value to determine if the column should be capable of representing only non-negative integers
     * (applies only for integer column and might not be supported by all vendors).
     *
     * @return Field
     */
    public function unsigned()
    {
        $this->fieldBuilder->option('unsigned', true);

        return $this;
    }

    /**
     * Boolean value to determine if the specified length of a string column should be fixed or varying
     * (applies only for string/binary column and might not be supported by all vendors).
     *
     * @param bool $fixed
     *
     * @return Field
     */
    public function fixed($fixed)
    {
        $this->fieldBuilder->option('fixed', $fixed);

        return $this;
    }

    /**
     * The comment of the column in the schema (might not be supported by all vendors).
     *
     * @param string $comment
     *
     * @return Field
     */
    public function comment($comment)
    {
        $this->fieldBuilder->option('comment', $comment);

        return $this;
    }

    /**
     * The collation of the column (only supported by Drizzle, Mysql, PostgreSQL>=9.1, Sqlite and SQLServer).
     *
     * @param string $collation
     *
     * @return Field
     */
    public function collation($collation)
    {
        $this->fieldBuilder->option('collation', $collation);

        return $this;
    }

    /**
     * @return Field
     */
    public function primary()
    {
        $this->fieldBuilder->makePrimaryKey();

        return $this;
    }

    /**
     * @param string|null $name
     *
     * @return Field
     */
    public function index($name = null)
    {
        $index = new Index(
            $this->metaDatabuilder,
            [$this->getName()]
        );

        if ($name !== null) {
            $index->name($name);
        }

        $this->callbackAndQueue($index);

        return $this;
    }

    /**
     * @return Field
     */
    public function useForVersioning()
    {
        $this->fieldBuilder->isVersionField();

        return $this;
    }

    /**
     * @return Field
     */
    public function build()
    {
        $this->fieldBuilder->build();

        $this->buildQueued();

        return $this;
    }

    /**
     * @return FieldBuilder
     */
    public function getBuilder()
    {
        return $this->fieldBuilder;
    }

    /**
     * Magic call method works as a proxy for the Doctrine FieldBuilder.
     *
     * @param string $method
     * @param array  $args
     *
     * @throws BadMethodCallException
     *
     * @return $this
     */
    public function __call($method, $args)
    {
        // Work around reserved keywords
        if ($method === 'default') {
            return call_user_func_array([$this, 'setDefault'], $args);
        }

        if ($this->hasMacro($method)) {
            return $this->queueMacro($method, $args);
        }

        if (method_exists($this->getBuilder(), $method)) {
            call_user_func_array([$this->getBuilder(), $method], $args);

            return $this;
        }

        throw new BadMethodCallException("FieldBuilder method [{$method}] does not exist.");
    }

    /**
     * The default value to set for the column if no value is supplied.
     *
     * @param string $default
     *
     * @return Field
     */
    protected function setDefault($default)
    {
        $this->fieldBuilder->option('default', $default);

        return $this;
    }
}


1			<?php
2
3			namespace LaravelDoctrine\Fluent\Builders;
4
5			use BadMethodCallException;
6			use Doctrine\Common\Persistence\Mapping\ClassMetadata;
7			use Doctrine\DBAL\Types\Type;
8			use Doctrine\ORM\Mapping\Builder\ClassMetadataBuilder;
9			use Doctrine\ORM\Mapping\Builder\FieldBuilder;
10			use Doctrine\ORM\Mapping\ClassMetadataInfo;
11			use LaravelDoctrine\Fluent\Buildable;
12			use LaravelDoctrine\Fluent\Builders\Traits\Macroable;
13			use LaravelDoctrine\Fluent\Builders\Traits\Queueable;
14			use LaravelDoctrine\Fluent\Builders\Traits\QueuesMacros;
15			use LaravelDoctrine\Fluent\Extensions\ExtensibleClassMetadata;
16			use LaravelDoctrine\Fluent\Extensions\Gedmo\GedmoFieldHints;
17
18			/**
19			* @method $this unique(boolean $flag = true) Boolean value to determine if the value of the column should be unique
20			* across all rows of the underlying entities table.
21			* @method $this nullable(boolean $flag = true) Determines if NULL values are allowed for this column.
22			* @method $this length(int $length) Used by the “string” type to determine its maximum length in the
23			* database. Doctrine does not validate the length of string values
24			* for you.
25			* @method $this columnName(string $column) By default the property name is used for the database column name also,
26			* however the ‘name’ attribute allows you to determine the column name.
27			* @method $this precision(int $precision) The precision for a decimal (exact numeric) column (applies only for
28			* decimal column), which is the maximum number of digits that are stored
29			* for the values.
30			* @method $this scale(int $scale) The scale for a decimal (exact numeric) column (applies only for
31			* decimal column), which represents the number of digits to the right of
32			* the decimal point and must not be greater than precision.
33			* @method $this default(string $default) The default value to set for the column if no value is supplied.
34			* @method $this columnDefinition(string $def) DDL SQL snippet that starts after the column name and specifies the
35			* complete (non-portable!) column definition. This attribute allows to
36			* make use of advanced RMDBS features. However you should make careful
37			* use of this feature and the consequences. SchemaTool will not detect
38			* changes on the column correctly anymore if you use “columnDefinition”.
39			* @method $this option($name, $value) Set custom options
40			*/
41			class Field implements Buildable
42			{
43			use Macroable;
44			use Queueable {
45			build as buildQueued;
46			}
47			use QueuesMacros;
48			use GedmoFieldHints;
49
50			/**
51			* @var FieldBuilder
52			*/
53			protected $fieldBuilder;
54
55			/**
56			* @var ClassMetadataBuilder
57			*/
58			protected $metaDatabuilder;
59
60			/**
61			* @var ClassMetadataInfo
62			*/
63			protected $classMetadata;
64
65			/**
66			* @var Type
67			*/
68			protected $type;
69
70			/**
71			* @var string
72			*/
73			protected $name;
74
75			/**
76			* Protected constructor to force usage of factory method.
77			*
78			* @param FieldBuilder $fieldBuilder
79			* @param ClassMetadataBuilder $builder
80			* @param Type $type
81			* @param string $name
82			*/
83			protected function __construct(FieldBuilder $fieldBuilder, ClassMetadataBuilder $builder, Type $type, $name)
84			{
85			$this->fieldBuilder = $fieldBuilder;
86			$this->metaDatabuilder = $builder;
87			$this->classMetadata = $builder->getClassMetadata();
88			$this->type = $type;
89			$this->name = $name;
90			}
91
92			/**
93			* @param ClassMetadataBuilder $builder
94			* @param string $type
95			* @param string $name
96			*
97			* @throws \Doctrine\DBAL\DBALException
98			*
99			* @return Field
100			*/
101			public static function make(ClassMetadataBuilder $builder, $type, $name)
102			{
103			$type = Type::getType($type);
104
105			$field = $builder->createField($name, $type->getName());
106
107			return new static($field, $builder, $type, $name);
108			}
109
110			/**
111			* @return string
112			*/
113			public function getName()
114			{
115			return $this->name;
116			}
117
118			/**
119			* @return Type
120			*/
121			public function getType()
122			{
123			return $this->type;
124			}
125
126			/**
127			* @return ClassMetadata\|ExtensibleClassMetadata
128			*/
129			public function getClassMetadata()
130			{
131			return $this->classMetadata;
132			}
133
134			/**
135			* By default the property name is used for the database column name also, however the ‘name’ attribute
136			* allows you to determine the column name.
137			*
138			* @param string $columnName
139			*
140			* @return $this
141			*/
142			public function name($columnName)
143			{
144			$this->columnName($columnName);
145
146			return $this;
147			}
148
149			/**
150			* @return Field
151			*/
152			public function autoIncrement()
153			{
154			$this->generatedValue();
155
156			return $this;
157			}
158
159			/**
160			* @param callable\|null $callback
161			*
162			* @return Field
163			*/
164			public function generatedValue(callable $callback = null)
165			{
166			$generatedValue = new GeneratedValue($this->fieldBuilder, $this->classMetadata);
167
168			if ($callback) {
169			$callback($generatedValue);
170			}
171
172			$generatedValue->build();
173
174			return $this;
175			}
176
177			/**
178			* Boolean value to determine if the column should be capable of representing only non-negative integers
179			* (applies only for integer column and might not be supported by all vendors).
180			*
181			* @return Field
182			*/
183			public function unsigned()
184			{
185			$this->fieldBuilder->option('unsigned', true);
186
187			return $this;
188			}
189
190			/**
191			* Boolean value to determine if the specified length of a string column should be fixed or varying
192			* (applies only for string/binary column and might not be supported by all vendors).
193			*
194			* @param bool $fixed
195			*
196			* @return Field
197			*/
198			public function fixed($fixed)
199			{
200			$this->fieldBuilder->option('fixed', $fixed);
201
202			return $this;
203			}
204
205			/**
206			* The comment of the column in the schema (might not be supported by all vendors).
207			*
208			* @param string $comment
209			*
210			* @return Field
211			*/
212			public function comment($comment)
213			{
214			$this->fieldBuilder->option('comment', $comment);
215
216			return $this;
217			}
218
219			/**
220			* The collation of the column (only supported by Drizzle, Mysql, PostgreSQL>=9.1, Sqlite and SQLServer).
221			*
222			* @param string $collation
223			*
224			* @return Field
225			*/
226			public function collation($collation)
227			{
228			$this->fieldBuilder->option('collation', $collation);
229
230			return $this;
231			}
232
233			/**
234			* @return Field
235			*/
236			public function primary()
237			{
238			$this->fieldBuilder->makePrimaryKey();
239
240			return $this;
241			}
242
243			/**
244			* @param string\|null $name
245			*
246			* @return Field
247			*/
248			public function index($name = null)
249			{
250			$index = new Index(
251			$this->metaDatabuilder,
252			[$this->getName()]
253			);
254
255			if ($name !== null) {
256			$index->name($name);
257			}
258
259			$this->callbackAndQueue($index);
260
261			return $this;
262			}
263
264			/**
265			* @return Field
266			*/
267			public function useForVersioning()
268			{
269			$this->fieldBuilder->isVersionField();
270
271			return $this;
272			}
273
274			/**
275			* @return Field
276			*/
277			public function build()
278			{
279			$this->fieldBuilder->build();
280
281			$this->buildQueued();
282
283			return $this;
284			}
285
286			/**
287			* @return FieldBuilder
288			*/
289			public function getBuilder()
290			{
291			return $this->fieldBuilder;
292			}
293
294			/**
295			* Magic call method works as a proxy for the Doctrine FieldBuilder.
296			*
297			* @param string $method
298			* @param array $args
299			*
300			* @throws BadMethodCallException
301			*
302			* @return $this
303			*/
304			public function __call($method, $args)
305			{
306			// Work around reserved keywords
307			if ($method === 'default') {
308			return call_user_func_array([$this, 'setDefault'], $args);
309			}
310
311			if ($this->hasMacro($method)) {
312			return $this->queueMacro($method, $args);
313			}
314
315			if (method_exists($this->getBuilder(), $method)) {
316			call_user_func_array([$this->getBuilder(), $method], $args);
317
318			return $this;
319			}
320
321			throw new BadMethodCallException("FieldBuilder method [{$method}] does not exist.");
322			}
323
324			/**
325			* The default value to set for the column if no value is supplied.
326			*
327			* @param string $default
328			*
329			* @return Field
330			*/
331			protected function setDefault($default)
332			{
333			$this->fieldBuilder->option('default', $default);
334
335			return $this;
336			}
337			}
338

laravel-doctrine / fluent

Push — alt-path-loader ( dd5973 )

Field::index() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like