MultiUnitSupport - Code Metrics - Inspection of "Apply fixes from StyleCI" - maksimru/multi-unit-models - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#5)

by Maksim

created 2019-08-14 18:49 UTC

MultiUnitSupport D

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	407
Duplicated Lines	1.47 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

Metric	Value
wmc	59
lcom	1
cbo	1
dl	6
loc	407
rs	4.08
c	0
b	0
f	0

25 Methods

Rating	Name	Duplication	Size	Complexity
A	getUnitConversionDataColumns()	0	6	1
A	getUnitConversionUnitColumns()	0	6	1
A	fillableFromArray()	0	4	1
A	getFillable()	0	4	1
A	getHidden()	0	4	1
B	bootMultiUnitSupport()	0	38	6
A	calculateMultiUnitConversionData()	0	13	2
A	getMultiUnitExistingConversionData()	0	4	1
A	getUnitAttributePostfix()	0	4	1
A	getUnitConversionDataPostfix()	0	4	1
A	getMultiUnitColumns()	0	4	1
A	getMultiUnitFieldSupportedUnits()	0	8	2
A	getMultiUnitFieldDefaultUnit()	0	10	2
B	getMultiUnitFieldValueByUnitName()	3	34	9
B	getMultiUnitFieldValue()	3	20	6
A	isMultiUnitField()	0	4	1
A	getMultiUnitFieldUnit()	0	16	4
A	forgetMultiUnitFieldUnitInput()	0	7	2
A	setMultiUnitFieldUnit()	0	5	1
A	resetMultiUnitFieldUnit()	0	4	1
A	hasSetMutator()	0	8	2
A	setMutatedAttributeValue()	0	11	2
A	processMultiUnitFieldChanges()	0	24	5
A	hasGetMutator()	0	8	3
A	mutateAttribute()	0	10	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like MultiUnitSupport often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use MultiUnitSupport, and based on these observations, apply Extract Interface, too.

<?php

namespace MaksimM\MultiUnitModels\Traits;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Arr;
use MaksimM\MultiUnitModels\Exceptions\NotSupportedMultiUnitField;
use UnitConverter\Unit\AbstractUnit;

trait MultiUnitSupport
{
    protected $unitAttributePostfix = '_units';
    protected $unitConversionDataPostfix = '_ucd';
    protected $multiUnitColumns = [];

    private function getUnitConversionDataColumns()
    {
        return array_map(function ($column) {
            return $column.$this->getUnitConversionDataPostfix();
        }, array_keys($this->getMultiUnitColumns()));
    }

    private function getUnitConversionUnitColumns()
    {
        return array_map(function ($column) {
            return $column.$this->getUnitAttributePostfix();
        }, array_keys($this->getMultiUnitColumns()));
    }

    /**
     * Allows to set input units and process them before multi-unit field.
     *
     * @param array $attributes
     *
     * @return array
     */
    protected function fillableFromArray(array $attributes)
    {
        return array_merge(array_intersect_key($attributes, array_flip($this->getUnitConversionUnitColumns())), parent::fillableFromArray($attributes));
    }

    /**
     * @return array
     */
    public function getFillable()
    {
        return array_merge($this->getUnitConversionDataColumns(), $this->getUnitConversionUnitColumns(), parent::getFillable());
    }

    /**
     * @return mixed
     */
    public function getHidden()
    {
        return array_merge(parent::getHidden(), $this->getUnitConversionDataColumns());
    }

    protected static function bootMultiUnitSupport()
    {
        //save conversion table if base value is changed
        static::creating(function ($model) {
            /**
             * @var Model|MultiUnitSupport $model
             */
            foreach ($model->getMultiUnitColumns() as $unitBasedColumn => $options) {
                if (isset($model->attributes[$unitBasedColumn])) {
                    $model->{$unitBasedColumn.$model->getUnitConversionDataPostfix()} = json_encode(
                        $model->calculateMultiUnitConversionData(
                            $model->attributes[$unitBasedColumn],
                            $model->getMultiUnitFieldUnit($unitBasedColumn),
                            $options['supported_units']
                        )
                    );
                    $model->{$unitBasedColumn} = $model->processMultiUnitFieldChanges(
                        $unitBasedColumn,
                        $model->{$unitBasedColumn}
                    );
                }
            }
            //prevent saving of unit columns
            foreach ($model->getUnitConversionUnitColumns() as $unitColumn) {
                if (isset($model->attributes[$unitColumn])) {
                    unset($model->attributes[$unitColumn]);
                }
            }
        });
        static::updating(function ($model) {
            /**
             * @var Model|MultiUnitSupport $model
             */
            foreach (Arr::only($model->getMultiUnitColumns(), array_keys($model->getDirty())) as $unitBasedColumn => $options) {
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
                $model->{$unitBasedColumn.$model->getUnitConversionDataPostfix()} = json_encode($model->calculateMultiUnitConversionData($model->getDirty()[$unitBasedColumn], new $options['default_unit'](), $options['supported_units']));
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            }
        });
    }

    /**
     * @param              $value
     * @param AbstractUnit $unit
     * @param string[]     $requiredUnits
     *
     * @return array
     */
    private function calculateMultiUnitConversionData($value, AbstractUnit $unit, $requiredUnits)
    {
        $conversionData = [];
        foreach ($requiredUnits as $requiredUnitClass) {
            /**
             * @var AbstractUnit $requiredUnit
             */
            $requiredUnit = new $requiredUnitClass();
            $conversionData[$requiredUnit->getSymbol()] = (new $unit($value))->as($requiredUnit);
        }

        return $conversionData;
    }

    public function getMultiUnitExistingConversionData($field)

    {
        return json_decode($this->{$field.$this->getUnitConversionDataPostfix()} ?? null);
    }

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

    /**
     * @return string
     */
    protected function getUnitConversionDataPostfix()
    {
        return $this->unitConversionDataPostfix;
    }

    /**
     * @return array
     */
    public function getMultiUnitColumns()
    {
        return $this->multiUnitColumns;
    }

    /**
     * @param $field
     *
     * @throws NotSupportedMultiUnitField
     *
     * @return AbstractUnit[]
     */
    public function getMultiUnitFieldSupportedUnits($field)
    {
        if ($this->isMultiUnitField($field)) {
            return $this->getMultiUnitColumns()[$field]['supported_units'];
        }

        throw new NotSupportedMultiUnitField($field);
    }

    /**
     * @param $field
     *
     * @throws NotSupportedMultiUnitField
     *
     * @return AbstractUnit
     */
    public function getMultiUnitFieldDefaultUnit($field)
    {
        if ($this->isMultiUnitField($field)) {
            $unitClass = $this->getMultiUnitColumns()[$field]['default_unit'];

            return new $unitClass();
        }

        throw new NotSupportedMultiUnitField($field);
    }

    /**
     * @param        $field
     * @param string $unit

     *
     * @throws NotSupportedMultiUnitField
     *
     * @return mixed
     */
    public function getMultiUnitFieldValueByUnitName($field, $unit = null)
    {
        if ($this->isMultiUnitField($field)) {
            if (isset($this->{$field})) {
                if (is_null($unit)) {
                    $unit = $this->getMultiUnitFieldUnit($field);
                } else {
                    foreach ($this->getMultiUnitFieldSupportedUnits($field) as $unitClass) {
                        /**
                         * @var AbstractUnit $unit
                         */
                        $supportedUnit = new $unitClass();
                        if (strtolower($supportedUnit->getSymbol()) == strtolower($unit)) {
                            $unit = $supportedUnit;
                            break;
                        }
                    }
                }
                if (is_string($unit)) {
                    throw new NotSupportedMultiUnitField($field);
                }
                $existingConversionData = $this->getMultiUnitExistingConversionData($field);
                if (!is_null($existingConversionData) && !is_null($existingConversionData->{$unit->getSymbol()})) {

                    return $existingConversionData->{$unit->getSymbol()};
                }

                return ($this->getMultiUnitFieldDefaultUnit($field)->setValue($this->{$field} ?? $this->attributes[$field]))->as(new $unit());
class MyClass { }

$x = new MyClass();
$x->foo = true;
            } else {
                return;
            }
        }

        throw new NotSupportedMultiUnitField($field);
    }

    /**
     * @param                   $field
     * @param AbstractUnit|null $unit
     *
     * @throws NotSupportedMultiUnitField
     *
     * @return mixed
     */
    public function getMultiUnitFieldValue($field, AbstractUnit $unit = null)
    {
        if ($this->isMultiUnitField($field)) {
            if (isset($this->{$field})) {
                if (is_null($unit)) {
                    $unit = $this->getMultiUnitFieldUnit($field);
                }
                $existingConversionData = $this->getMultiUnitExistingConversionData($field);
                if (!is_null($existingConversionData) && !is_null($existingConversionData->{$unit->getSymbol()})) {

                    return $existingConversionData->{$unit->getSymbol()};
                }

                return ($this->getMultiUnitFieldDefaultUnit($field)->setValue($this->{$field} ?? $this->attributes[$field]))->as(new $unit());
            } else {
                return;
            }
        }

        throw new NotSupportedMultiUnitField($field);
    }

    protected function isMultiUnitField($field)
    {
        return isset($this->getMultiUnitColumns()[$field]);
    }

    /**
     * @param $field
     *
     * @throws NotSupportedMultiUnitField
     *
     * @return AbstractUnit
     */
    protected function getMultiUnitFieldUnit($field)
    {
        if (isset($this->{$field.$this->getUnitAttributePostfix()})) {
            foreach ($this->getMultiUnitFieldSupportedUnits($field) as $unitClass) {
                /**
                 * @var AbstractUnit $unit
                 */
                $unit = new $unitClass();
                if (strtolower($unit->getSymbol()) == strtolower($this->{$field.$this->getUnitAttributePostfix()})) {
                    return $unit;
                }
            }
        }

        return $this->getMultiUnitFieldDefaultUnit($field);
    }

    protected function forgetMultiUnitFieldUnitInput($field)
    {
        //prevent column_units to by saved to DB
        if (isset($this->attributes[$field.$this->getUnitAttributePostfix()])) {
            $this->syncOriginalAttribute($field.$this->getUnitAttributePostfix());
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        }
    }

    protected function setMultiUnitFieldUnit($field, AbstractUnit $unit)
    {
        $this->{$field.$this->getUnitAttributePostfix()} = $unit->getSymbol();
        $this->forgetMultiUnitFieldUnitInput($field);
    }

    /**
     * @param $field
     *
     * @throws NotSupportedMultiUnitField
     */
    protected function resetMultiUnitFieldUnit($field)
    {
        $this->setMultiUnitFieldUnit($field, $this->getMultiUnitFieldDefaultUnit($field));
    }

    /**
     * Determine if a set mutator exists for an attribute.
     *
     * @param string $key
     *
     * @return bool
     */
    public function hasSetMutator($key)
    {
        if ($this->isMultiUnitField($key)) {
            return true;
        }

        return parent::hasSetMutator($key);
    }

    /**
     * Set the value of an attribute using its mutator.
     *
     * @param string $key
     * @param mixed  $value
     *
     * @throws NotSupportedMultiUnitField
     *
     * @return mixed
     */
    protected function setMutatedAttributeValue($key, $value)
    {
        if ($this->isMultiUnitField($key)) {
            $value = $this->processMultiUnitFieldChanges($key, $value);
            $this->attributes[$key] = $value;

            return $value;
        }

        parent::setMutatedAttributeValue($key, $value);
    }

    /**
     * Detect changes and set proper base value.
     *
     * @param $field
     * @param $value
     *
     * @throws NotSupportedMultiUnitField
     *
     * @return mixed
     */
    private function processMultiUnitFieldChanges($field, $value)
    {
        $existingConversionData = $this->getMultiUnitExistingConversionData($field);
        if (!is_null($existingConversionData)) {
            $inputUnit = $this->getMultiUnitFieldUnit($field);
            //change existing value only in case if new value doesn't match with stored conversion table or not exists
            if (!isset($existingConversionData->{$inputUnit->getSymbol()}) || $value != $existingConversionData->{$inputUnit->getSymbol()}) {
                $this->resetMultiUnitFieldUnit($field);

                return (new $inputUnit($value))->as($this->getMultiUnitFieldDefaultUnit($field));
            } elseif ($value == $existingConversionData->{$inputUnit->getSymbol()}) {
                //forget changes if value actually isn't changed
                $this->resetMultiUnitFieldUnit($field);
                $originalValue = $existingConversionData->{$this->getMultiUnitFieldDefaultUnit($field)->getSymbol()};
                $this->attributes[$field] = $originalValue;
                $this->syncOriginalAttribute($field);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

                return $originalValue;
            }
            $this->resetMultiUnitFieldUnit($field);
        }

        return $value;
    }

    /**
     * Determine if a get mutator exists for an attribute.
     *coo.
     *
     * @param string $key
     *
     * @return bool
     */
    public function hasGetMutator($key)
    {
        if ($this->isMultiUnitField($key) && isset($this->{$key})) {
            return true;
        }

        return parent::hasGetMutator($key);
    }

    /**
     * Get the value of an attribute using its mutator.
     *
     * @param string $key
     * @param mixed  $value
     *
     * @throws NotSupportedMultiUnitField
     *
     * @return mixed
     */
    public function mutateAttribute($key, $value)
    {
        if ($this->isMultiUnitField($key)) {
            $requestedUnit = $this->getMultiUnitFieldUnit($key);

            return $this->getMultiUnitFieldValue($key, new $requestedUnit());
        }

        return parent::mutateAttribute($key, $value);
    }
}


1		<?php
2
3		namespace MaksimM\MultiUnitModels\Traits;
4
5		use Illuminate\Database\Eloquent\Model;
6		use Illuminate\Support\Arr;
7		use MaksimM\MultiUnitModels\Exceptions\NotSupportedMultiUnitField;
8		use UnitConverter\Unit\AbstractUnit;
9
10		trait MultiUnitSupport
11		{
12		protected $unitAttributePostfix = '_units';
13		protected $unitConversionDataPostfix = '_ucd';
14		protected $multiUnitColumns = [];
15
16		private function getUnitConversionDataColumns()
17		{
18		return array_map(function ($column) {
19		return $column.$this->getUnitConversionDataPostfix();
20		}, array_keys($this->getMultiUnitColumns()));
21		}
22
23		private function getUnitConversionUnitColumns()
24		{
25		return array_map(function ($column) {
26		return $column.$this->getUnitAttributePostfix();
27		}, array_keys($this->getMultiUnitColumns()));
28		}
29
30		/**
31		* Allows to set input units and process them before multi-unit field.
32		*
33		* @param array $attributes
34		*
35		* @return array
36		*/
37		protected function fillableFromArray(array $attributes)
38		{
39		return array_merge(array_intersect_key($attributes, array_flip($this->getUnitConversionUnitColumns())), parent::fillableFromArray($attributes));
40		}
41
42		/**
43		* @return array
44		*/
45		public function getFillable()
46		{
47		return array_merge($this->getUnitConversionDataColumns(), $this->getUnitConversionUnitColumns(), parent::getFillable());
48		}
49
50		/**
51		* @return mixed
52		*/
53		public function getHidden()
54		{
55		return array_merge(parent::getHidden(), $this->getUnitConversionDataColumns());
56		}
57
58		protected static function bootMultiUnitSupport()
59		{
60		//save conversion table if base value is changed
61		static::creating(function ($model) {
62		/**
63		* @var Model\|MultiUnitSupport $model
64		*/
65		foreach ($model->getMultiUnitColumns() as $unitBasedColumn => $options) {
66		if (isset($model->attributes[$unitBasedColumn])) {
67		$model->{$unitBasedColumn.$model->getUnitConversionDataPostfix()} = json_encode(
68		$model->calculateMultiUnitConversionData(
69		$model->attributes[$unitBasedColumn],
70		$model->getMultiUnitFieldUnit($unitBasedColumn),
71		$options['supported_units']
72		)
73		);
74		$model->{$unitBasedColumn} = $model->processMultiUnitFieldChanges(
75		$unitBasedColumn,
76		$model->{$unitBasedColumn}
77		);
78		}
79		}
80		//prevent saving of unit columns
81		foreach ($model->getUnitConversionUnitColumns() as $unitColumn) {
82		if (isset($model->attributes[$unitColumn])) {
83		unset($model->attributes[$unitColumn]);
84		}
85		}
86		});
87		static::updating(function ($model) {
88		/**
89		* @var Model\|MultiUnitSupport $model
90		*/
91		foreach (Arr::only($model->getMultiUnitColumns(), array_keys($model->getDirty())) as $unitBasedColumn => $options) {
		0 ignored issues – show Bug introduced 2019-05-03 03:08 UTC by Report Bug Copy Issue Report It seems like `getDirty()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
92		$model->{$unitBasedColumn.$model->getUnitConversionDataPostfix()} = json_encode($model->calculateMultiUnitConversionData($model->getDirty()[$unitBasedColumn], new $options['default_unit'](), $options['supported_units']));
		0 ignored issues – show Bug introduced 2019-05-03 03:08 UTC by Report Bug Copy Issue Report It seems like `getDirty()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
93		}
94		});
95		}
96
97		/**
98		* @param $value
99		* @param AbstractUnit $unit
100		* @param string[] $requiredUnits
101		*
102		* @return array
103		*/
104		private function calculateMultiUnitConversionData($value, AbstractUnit $unit, $requiredUnits)
105		{
106		$conversionData = [];
107		foreach ($requiredUnits as $requiredUnitClass) {
108		/**
109		* @var AbstractUnit $requiredUnit
110		*/
111		$requiredUnit = new $requiredUnitClass();
112		$conversionData[$requiredUnit->getSymbol()] = (new $unit($value))->as($requiredUnit);
113		}
114
115		return $conversionData;
116		}
117
118		public function getMultiUnitExistingConversionData($field)
		0 ignored issues – show Documentation introduced 2019-05-03 03:07 UTC by Report Bug Copy Issue Report The return type could not be reliably inferred; please add a `@return` annotation. Our type inference engine in quite powerful, but sometimes the code does not provide enough clues to go by. In these cases we request you to add a `@return` annotation as described here. Loading history...
119		{
120		return json_decode($this->{$field.$this->getUnitConversionDataPostfix()} ?? null);
121		}
122
123		/**
124		* @return string
125		*/
126		public function getUnitAttributePostfix()
127		{
128		return $this->unitAttributePostfix;
129		}
130
131		/**
132		* @return string
133		*/
134		protected function getUnitConversionDataPostfix()
135		{
136		return $this->unitConversionDataPostfix;
137		}
138
139		/**
140		* @return array
141		*/
142		public function getMultiUnitColumns()
143		{
144		return $this->multiUnitColumns;
145		}
146
147		/**
148		* @param $field
149		*
150		* @throws NotSupportedMultiUnitField
151		*
152		* @return AbstractUnit[]
153		*/
154		public function getMultiUnitFieldSupportedUnits($field)
155		{
156		if ($this->isMultiUnitField($field)) {
157		return $this->getMultiUnitColumns()[$field]['supported_units'];
158		}
159
160		throw new NotSupportedMultiUnitField($field);
161		}
162
163		/**
164		* @param $field
165		*
166		* @throws NotSupportedMultiUnitField
167		*
168		* @return AbstractUnit
169		*/
170		public function getMultiUnitFieldDefaultUnit($field)
171		{
172		if ($this->isMultiUnitField($field)) {
173		$unitClass = $this->getMultiUnitColumns()[$field]['default_unit'];
174
175		return new $unitClass();
176		}
177
178		throw new NotSupportedMultiUnitField($field);
179		}
180
181		/**
182		* @param $field
183		* @param string $unit
		0 ignored issues – show Documentation introduced 2019-08-14 18:50 UTC by Report Bug Copy Issue Report Should the type for parameter `$unit` not be `string\|null`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
184		*
185		* @throws NotSupportedMultiUnitField
186		*
187		* @return mixed
188		*/
189		public function getMultiUnitFieldValueByUnitName($field, $unit = null)
190		{
191		if ($this->isMultiUnitField($field)) {
192		if (isset($this->{$field})) {
193		if (is_null($unit)) {
194		$unit = $this->getMultiUnitFieldUnit($field);
195		} else {
196		foreach ($this->getMultiUnitFieldSupportedUnits($field) as $unitClass) {
197		/**
198		* @var AbstractUnit $unit
199		*/
200		$supportedUnit = new $unitClass();
201		if (strtolower($supportedUnit->getSymbol()) == strtolower($unit)) {
202		$unit = $supportedUnit;
203		break;
204		}
205		}
206		}
207		if (is_string($unit)) {
208		throw new NotSupportedMultiUnitField($field);
209		}
210		$existingConversionData = $this->getMultiUnitExistingConversionData($field);
211	View Code Duplication	if (!is_null($existingConversionData) && !is_null($existingConversionData->{$unit->getSymbol()})) {
		0 ignored issues – show Duplication introduced 2019-08-14 18:50 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
212		return $existingConversionData->{$unit->getSymbol()};
213		}
214
215		return ($this->getMultiUnitFieldDefaultUnit($field)->setValue($this->{$field} ?? $this->attributes[$field]))->as(new $unit());
		0 ignored issues – show Bug introduced 2019-05-20 21:15 UTC by Report Bug Copy Issue Report The property `attributes` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
216		} else {
217		return;
218		}
219		}
220
221		throw new NotSupportedMultiUnitField($field);
222		}
223
224		/**
225		* @param $field
226		* @param AbstractUnit\|null $unit
227		*
228		* @throws NotSupportedMultiUnitField
229		*
230		* @return mixed
231		*/
232		public function getMultiUnitFieldValue($field, AbstractUnit $unit = null)
233		{
234		if ($this->isMultiUnitField($field)) {
235		if (isset($this->{$field})) {
236		if (is_null($unit)) {
237		$unit = $this->getMultiUnitFieldUnit($field);
238		}
239		$existingConversionData = $this->getMultiUnitExistingConversionData($field);
240	View Code Duplication	if (!is_null($existingConversionData) && !is_null($existingConversionData->{$unit->getSymbol()})) {
		0 ignored issues – show Duplication introduced 2019-08-14 18:50 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
241		return $existingConversionData->{$unit->getSymbol()};
242		}
243
244		return ($this->getMultiUnitFieldDefaultUnit($field)->setValue($this->{$field} ?? $this->attributes[$field]))->as(new $unit());
245		} else {
246		return;
247		}
248		}
249
250		throw new NotSupportedMultiUnitField($field);
251		}
252
253		protected function isMultiUnitField($field)
254		{
255		return isset($this->getMultiUnitColumns()[$field]);
256		}
257
258		/**
259		* @param $field
260		*
261		* @throws NotSupportedMultiUnitField
262		*
263		* @return AbstractUnit
264		*/
265		protected function getMultiUnitFieldUnit($field)
266		{
267		if (isset($this->{$field.$this->getUnitAttributePostfix()})) {
268		foreach ($this->getMultiUnitFieldSupportedUnits($field) as $unitClass) {
269		/**
270		* @var AbstractUnit $unit
271		*/
272		$unit = new $unitClass();
273		if (strtolower($unit->getSymbol()) == strtolower($this->{$field.$this->getUnitAttributePostfix()})) {
274		return $unit;
275		}
276		}
277		}
278
279		return $this->getMultiUnitFieldDefaultUnit($field);
280		}
281
282		protected function forgetMultiUnitFieldUnitInput($field)
283		{
284		//prevent column_units to by saved to DB
285		if (isset($this->attributes[$field.$this->getUnitAttributePostfix()])) {
286		$this->syncOriginalAttribute($field.$this->getUnitAttributePostfix());
		0 ignored issues – show Bug introduced 2019-05-03 03:07 UTC by Report Bug Copy Issue Report It seems like `syncOriginalAttribute()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
287		}
288		}
289
290		protected function setMultiUnitFieldUnit($field, AbstractUnit $unit)
291		{
292		$this->{$field.$this->getUnitAttributePostfix()} = $unit->getSymbol();
293		$this->forgetMultiUnitFieldUnitInput($field);
294		}
295
296		/**
297		* @param $field
298		*
299		* @throws NotSupportedMultiUnitField
300		*/
301		protected function resetMultiUnitFieldUnit($field)
302		{
303		$this->setMultiUnitFieldUnit($field, $this->getMultiUnitFieldDefaultUnit($field));
304		}
305
306		/**
307		* Determine if a set mutator exists for an attribute.
308		*
309		* @param string $key
310		*
311		* @return bool
312		*/
313		public function hasSetMutator($key)
314		{
315		if ($this->isMultiUnitField($key)) {
316		return true;
317		}
318
319		return parent::hasSetMutator($key);
320		}
321
322		/**
323		* Set the value of an attribute using its mutator.
324		*
325		* @param string $key
326		* @param mixed $value
327		*
328		* @throws NotSupportedMultiUnitField
329		*
330		* @return mixed
331		*/
332		protected function setMutatedAttributeValue($key, $value)
333		{
334		if ($this->isMultiUnitField($key)) {
335		$value = $this->processMultiUnitFieldChanges($key, $value);
336		$this->attributes[$key] = $value;
337
338		return $value;
339		}
340
341		parent::setMutatedAttributeValue($key, $value);
342		}
343
344		/**
345		* Detect changes and set proper base value.
346		*
347		* @param $field
348		* @param $value
349		*
350		* @throws NotSupportedMultiUnitField
351		*
352		* @return mixed
353		*/
354		private function processMultiUnitFieldChanges($field, $value)
355		{
356		$existingConversionData = $this->getMultiUnitExistingConversionData($field);
357		if (!is_null($existingConversionData)) {
358		$inputUnit = $this->getMultiUnitFieldUnit($field);
359		//change existing value only in case if new value doesn't match with stored conversion table or not exists
360		if (!isset($existingConversionData->{$inputUnit->getSymbol()}) \|\| $value != $existingConversionData->{$inputUnit->getSymbol()}) {
361		$this->resetMultiUnitFieldUnit($field);
362
363		return (new $inputUnit($value))->as($this->getMultiUnitFieldDefaultUnit($field));
364		} elseif ($value == $existingConversionData->{$inputUnit->getSymbol()}) {
365		//forget changes if value actually isn't changed
366		$this->resetMultiUnitFieldUnit($field);
367		$originalValue = $existingConversionData->{$this->getMultiUnitFieldDefaultUnit($field)->getSymbol()};
368		$this->attributes[$field] = $originalValue;
369		$this->syncOriginalAttribute($field);
		0 ignored issues – show Bug introduced 2019-05-03 03:07 UTC by Report Bug Copy Issue Report It seems like `syncOriginalAttribute()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
370
371		return $originalValue;
372		}
373		$this->resetMultiUnitFieldUnit($field);
374		}
375
376		return $value;
377		}
378
379		/**
380		* Determine if a get mutator exists for an attribute.
381		*coo.
382		*
383		* @param string $key
384		*
385		* @return bool
386		*/
387		public function hasGetMutator($key)
388		{
389		if ($this->isMultiUnitField($key) && isset($this->{$key})) {
390		return true;
391		}
392
393		return parent::hasGetMutator($key);
394		}
395
396		/**
397		* Get the value of an attribute using its mutator.
398		*
399		* @param string $key
400		* @param mixed $value
401		*
402		* @throws NotSupportedMultiUnitField
403		*
404		* @return mixed
405		*/
406		public function mutateAttribute($key, $value)
407		{
408		if ($this->isMultiUnitField($key)) {
409		$requestedUnit = $this->getMultiUnitFieldUnit($key);
410
411		return $this->getMultiUnitFieldValue($key, new $requestedUnit());
412		}
413
414		return parent::mutateAttribute($key, $value);
415		}
416		}
417

maksimru / multi-unit-models