MultiUnitSupport::getUnitConversionDataPostfix() - Code Metrics - Inspection of "major refactoring and improvements" - maksimru/multi-unit-models - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#16)

by Maksim

created 2019-11-14 14:10 UTC

MultiUnitSupport::getUnitConversionDataPostfix() A

↳ Parent: MultiUnitSupport

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

namespace MaksimM\MultiUnitModels\Traits;

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

trait MultiUnitSupport
{
    use ModelConfiguration;

    protected $unitConversionDataPostfix = '_ucd';
    protected $multiUnitColumns = [];
    protected $multiUnitSelectedUnits = [];

    private function getUnitConversionDataColumns()

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

    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) {
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                if (isset($model->attributes[$unitBasedColumn])) {
                    $model->{$unitBasedColumn.$model->getUnitConversionDataPostfix()} = json_encode(
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                        $model->calculateMultiUnitConversionData(
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                            $model->attributes[$unitBasedColumn],
                            $model->getMultiUnitFieldUnit($unitBasedColumn),
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                            $options['supported_units']
                        )
                    );
                    $model->attributes[$unitBasedColumn] = $model->processMultiUnitFieldChanges(
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                        $unitBasedColumn,
                        $model->{$unitBasedColumn}
                    );
                }
            }
        });
        static::updating(function ($model) {
            /**
             * @var Model|MultiUnitSupport $model
             */
            foreach (Arr::only($model->getMultiUnitColumns(), array_keys($model->getDirty())) as $unitBasedColumn => $options) {
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                $newValue = $model->attributes[$unitBasedColumn];
                $newValueInDefaultUnits = $model->processMultiUnitFieldChanges(
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                    $unitBasedColumn,
                    $newValue
                );
                $model->{$unitBasedColumn.$model->getUnitConversionDataPostfix()} = json_encode(
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                    $model->calculateMultiUnitConversionData(
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                        $newValue,
                        $model->getMultiUnitFieldUnit($unitBasedColumn),
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                        $options['supported_units']
                    )
                );
                $model->attributes[$unitBasedColumn] = $newValueInDefaultUnits;
            }
        });
    }

    /**
     * @param              $value
     * @param AbstractUnit $unit
     * @param string[]     $requiredUnits
     *
     * @return array|null
     */
    private function calculateMultiUnitConversionData($value, AbstractUnit $unit, $requiredUnits)
    {
        if (is_null($value)) {
            return;
        }

        $conversionData = [];
        foreach ($requiredUnits as $requiredUnitClass) {
            /**
             * @var AbstractUnit $requiredUnit
             */
            $requiredUnit = new $requiredUnitClass();
            $conversionData[$requiredUnit->getId()] = (new $unit($value))->as($requiredUnit);
        }

        return $conversionData;
    }

    public function getMultiUnitExistingConversionData($field)

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

    /**
     * @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
     *
     * @throws NotSupportedMultiUnitField
     *
     * @return AbstractUnit
     */
    public function getMultiUnitFieldSelectedUnit($field)
    {
        if ($this->isMultiUnitField($field)) {
            $unitClass = $this->multiUnitSelectedUnits[$field] ?? $this->getMultiUnitFieldDefaultUnit($field);

            return new $unitClass();
        }

        throw new NotSupportedMultiUnitField($field);
    }

    /**
     * @param $field
     * @param string $unit
     *
     * @throws NotSupportedMultiUnitField
     * @throws NotSupportedMultiUnitFieldUnit
     */
    public function setMultiUnitFieldSelectedUnit($field, $unit)
    {
        if ($this->isMultiUnitField($field)) {
            $found = false;
            foreach ($this->getMultiUnitFieldSupportedUnits($field) as $unitClass) {

                /**
                 * @var AbstractUnit $unit
                 */
                $supportedUnit = new $unitClass();
                if (strtolower($supportedUnit->getId()) == strtolower($unit)) {
                    $found = true;
                    break;
                }
            }
            if ($found) {
                $this->multiUnitSelectedUnits[$field] = $unitClass;
foreach ($a as $b) {
}

// $b is defined here only if $a has elements, for example if $a is array()
// then $b would not be defined here. To avoid that, we recommend to set a
// default value for $b.


// Better
$b = 0; // or whatever default makes sense in your context
foreach ($a as $b) {
}

// $b is now guaranteed to be defined here.
            } else {
                throw new NotSupportedMultiUnitFieldUnit($field, $unit);
            }
        } else {
            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->getId()) == 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->getId()})) {

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

                return ($this->getMultiUnitFieldSelectedUnit($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->getId()})) {

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

                return ($this->getMultiUnitFieldSelectedUnit($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, $preferDefault = false)
    {
        return $preferDefault ? $this->getMultiUnitFieldDefaultUnit($field) : $this->getMultiUnitFieldSelectedUnit($field);
    }
}


Pull Request — master (#16)

MultiUnitSupport::getUnitConversionDataPostfix() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

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 MaksimM\MultiUnitModels\Exceptions\NotSupportedMultiUnitFieldUnit;
9			use UnitConverter\Unit\AbstractUnit;
10
11			trait MultiUnitSupport
12			{
13			use ModelConfiguration;
14
15			protected $unitConversionDataPostfix = '_ucd';
16			protected $multiUnitColumns = [];
17			protected $multiUnitSelectedUnits = [];
18
19			private function getUnitConversionDataColumns()
			0 ignored issues – show Unused Code introduced 2019-11-14 00:26 UTC by Report Bug Copy Issue Report This method is not used, and could be removed. Loading history...
20			{
21			return array_map(function ($column) {
22			return $column.$this->getUnitConversionDataPostfix();
23			}, array_keys($this->getMultiUnitColumns()));
24			}
25
26			protected static function bootMultiUnitSupport()
27			{
28			//save conversion table if base value is changed
29			static::creating(function ($model) {
30			/**
31			* @var Model\|MultiUnitSupport $model
32			*/
33			foreach ($model->getMultiUnitColumns() as $unitBasedColumn => $options) {
			0 ignored issues – show Bug introduced 2019-05-03 03:07 UTC by Report Bug Copy Issue Report The method `getMultiUnitColumns` does only exist in `MaksimM\MultiUnitModels\Traits\MultiUnitSupport`, but not in `Illuminate\Database\Eloquent\Model`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
34			if (isset($model->attributes[$unitBasedColumn])) {
35			$model->{$unitBasedColumn.$model->getUnitConversionDataPostfix()} = json_encode(
			0 ignored issues – show Bug introduced 2019-05-20 18:36 UTC by Report Bug Copy Issue Report The method `getUnitConversionDataPostfix` does only exist in `MaksimM\MultiUnitModels\Traits\MultiUnitSupport`, but not in `Illuminate\Database\Eloquent\Model`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
36			$model->calculateMultiUnitConversionData(
			0 ignored issues – show Bug introduced 2019-05-20 18:36 UTC by Report Bug Copy Issue Report The method `calculateMultiUnitConversionData` does only exist in `MaksimM\MultiUnitModels\Traits\MultiUnitSupport`, but not in `Illuminate\Database\Eloquent\Model`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...

maksimru / multi-unit-models

Pull Request — master (#16)

MultiUnitSupport::getUnitConversionDataPostfix() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like