CanCascadeFields - Code Metrics - Inspection of "Merge pull request #4814 from kaodouqifei/master" - z-song/laravel-admin - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 303741...88bbbb )

by Song

created 2020-08-07 03:32 UTC

CanCascadeFields A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	239
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

Metric	Value
dl	0
loc	239
rs	9.36
c	0
b	0
f	0
wmc	38
lcom	1
cbo	4

9 Methods

Rating	Name	Size	Complexity
A	fill()	6	1
A	when()	14	2
A	formatValues()	12	3
A	addDependents()	10	1
A	getCascadeClass()	8	2
A	applyCascadeConditions()	11	4
C	hitsCondition()	35	12
B	addCascadeScript()	60	2
B	getFormFrontValue()	23	11

<?php

namespace Encore\Admin\Form\Field;

use Encore\Admin\Admin;
use Encore\Admin\Form;
use Illuminate\Support\Arr;

/**
 * @property Form $form
 */
trait CanCascadeFields
{
    /**
     * @var array
     */
    protected $conditions = [];

    /**
     * @param $operator
     * @param $value
     * @param $closure
     *
     * @return $this
     */
    public function when($operator, $value, $closure = null)
    {
        if (func_num_args() == 2) {
            $closure = $value;
            $value = $operator;
            $operator = '=';
        }

        $this->formatValues($operator, $value);

        $this->addDependents($operator, $value, $closure);

        return $this;
    }

    /**
     * @param string $operator
     * @param mixed  $value
     */
    protected function formatValues(string $operator, &$value)
    {
        if (in_array($operator, ['in', 'notIn'])) {
            $value = Arr::wrap($value);
        }

        if (is_array($value)) {
            $value = array_map('strval', $value);
        } else {
            $value = strval($value);
        }
    }

    /**
     * @param string   $operator
     * @param mixed    $value
     * @param \Closure $closure
     */
    protected function addDependents(string $operator, $value, \Closure $closure)
    {
        $this->conditions[] = compact('operator', 'value', 'closure');

        $this->form->cascadeGroup($closure, [
            'column' => $this->column(),
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            'index'  => count($this->conditions) - 1,
            'class'  => $this->getCascadeClass($value),
        ]);
    }

    /**
     * {@inheritdoc}
     */
    public function fill($data)
    {
        parent::fill($data);

        $this->applyCascadeConditions();
    }

    /**
     * @param mixed $value
     *
     * @return string
     */
    protected function getCascadeClass($value)
    {
        if (is_array($value)) {
            $value = implode('-', $value);
        }

        return sprintf('cascade-%s-%s', $this->getElementClassString(), $value);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
    }

    /**
     * Apply conditions to dependents fields.
     *
     * @return void
     */
    protected function applyCascadeConditions()
    {
        if( $this->form ) {
            $this->form->fields()
                ->filter(function (Form\Field $field) {
                    return $field instanceof CascadeGroup
                        && $field->dependsOn($this)
                        && $this->hitsCondition($field);
                })->each->visiable();
        }
    }

    /**
     * @param CascadeGroup $group
     *
     * @throws \Exception
     *
     * @return bool
     */
    protected function hitsCondition(CascadeGroup $group)
    {
        $condition = $this->conditions[$group->index()];

        extract($condition);

        $old = old($this->column(), $this->value());
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

        switch ($operator) {
            case '=':
                return $old == $value;
            case '>':
                return $old > $value;
            case '<':
                return $old < $value;
            case '>=':
                return $old >= $value;
            case '<=':
                return $old <= $value;
            case '!=':
                return $old != $value;
            case 'in':
                return in_array($old, $value);
            case 'notIn':
                return !in_array($old, $value);
            case 'has':
                return in_array($value, $old);
            case 'oneIn':
                return count(array_intersect($value, $old)) >= 1;
            case 'oneNotIn':
                return count(array_intersect($value, $old)) == 0;
            default:
                throw new \Exception("Operator [$operator] not support.");
        }
    }

    /**
     * Add cascade scripts to contents.
     *
     * @return void
     */
    protected function addCascadeScript()
    {
        if (empty($this->conditions)) {
            return;
        }

        $cascadeGroups = collect($this->conditions)->map(function ($condition) {
            return [
                'class'    => $this->getCascadeClass($condition['value']),
                'operator' => $condition['operator'],
                'value'    => $condition['value'],
            ];
        })->toJson();

        $script = <<<SCRIPT
;(function () {
    var operator_table = {
        '=': function(a, b) {
            if ($.isArray(a) && $.isArray(b)) {
                return $(a).not(b).length === 0 && $(b).not(a).length === 0;
            }

            return a == b;
        },
        '>': function(a, b) { return a > b; },
        '<': function(a, b) { return a < b; },
        '>=': function(a, b) { return a >= b; },
        '<=': function(a, b) { return a <= b; },
        '!=': function(a, b) {
             if ($.isArray(a) && $.isArray(b)) {
                return !($(a).not(b).length === 0 && $(b).not(a).length === 0);
             }

             return a != b;
        },
        'in': function(a, b) { return $.inArray(a, b) != -1; },
        'notIn': function(a, b) { return $.inArray(a, b) == -1; },
        'has': function(a, b) { return $.inArray(b, a) != -1; },
        'oneIn': function(a, b) { return a.filter(v => b.includes(v)).length >= 1; },
        'oneNotIn': function(a, b) { return a.filter(v => b.includes(v)).length == 0; },
    };
    var cascade_groups = {$cascadeGroups};
    $('{$this->getElementClassSelector()}').on('{$this->cascadeEvent}', function (e) {
class MyClass { }

$x = new MyClass();
$x->foo = true;

        {$this->getFormFrontValue()}

        cascade_groups.forEach(function (event) {
            var group = $('div.cascade-group.'+event.class);
            if( operator_table[event.operator](checked, event.value) ) {
                group.removeClass('hide');
            } else {
                group.addClass('hide');
            }
        });
    })
})();
SCRIPT;

        Admin::script($script);
    }

    /**
     * @return string
     */
    protected function getFormFrontValue()
    {
        switch (get_class($this)) {
            case Radio::class:
            case RadioButton::class:
            case RadioCard::class:
            case Select::class:
            case BelongsTo::class:
            case BelongsToMany::class:
            case MultipleSelect::class:
                return 'var checked = $(this).val();';
            case Checkbox::class:
            case CheckboxButton::class:
            case CheckboxCard::class:
                return <<<SCRIPT
var checked = $('{$this->getElementClassSelector()}:checked').map(function(){
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
  return $(this).val();
}).get();
SCRIPT;
            default:
                throw new \InvalidArgumentException('Invalid form field type');
        }
    }
}


1			<?php
2
3			namespace Encore\Admin\Form\Field;
4
5			use Encore\Admin\Admin;
6			use Encore\Admin\Form;
7			use Illuminate\Support\Arr;
8
9			/**
10			* @property Form $form
11			*/
12			trait CanCascadeFields
13			{
14			/**
15			* @var array
16			*/
17			protected $conditions = [];
18
19			/**
20			* @param $operator
21			* @param $value
22			* @param $closure
23			*
24			* @return $this
25			*/
26			public function when($operator, $value, $closure = null)
27			{
28			if (func_num_args() == 2) {
29			$closure = $value;
30			$value = $operator;
31			$operator = '=';
32			}
33
34			$this->formatValues($operator, $value);
35
36			$this->addDependents($operator, $value, $closure);
37
38			return $this;
39			}
40
41			/**
42			* @param string $operator
43			* @param mixed $value
44			*/
45			protected function formatValues(string $operator, &$value)
46			{
47			if (in_array($operator, ['in', 'notIn'])) {
48			$value = Arr::wrap($value);
49			}
50
51			if (is_array($value)) {
52			$value = array_map('strval', $value);
53			} else {
54			$value = strval($value);
55			}
56			}
57
58			/**
59			* @param string $operator
60			* @param mixed $value
61			* @param \Closure $closure
62			*/
63			protected function addDependents(string $operator, $value, \Closure $closure)
64			{
65			$this->conditions[] = compact('operator', 'value', 'closure');
66
67			$this->form->cascadeGroup($closure, [
68			'column' => $this->column(),
			0 ignored issues – show Bug introduced 2020-05-27 08:51 UTC by Report Bug Copy Issue Report It seems like `column()` 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...
69			'index' => count($this->conditions) - 1,
70			'class' => $this->getCascadeClass($value),
71			]);
72			}
73
74			/**
75			* {@inheritdoc}
76			*/
77			public function fill($data)
78			{
79			parent::fill($data);
80
81			$this->applyCascadeConditions();
82			}
83
84			/**
85			* @param mixed $value
86			*
87			* @return string
88			*/
89			protected function getCascadeClass($value)
90			{
91			if (is_array($value)) {
92			$value = implode('-', $value);
93			}
94
95			return sprintf('cascade-%s-%s', $this->getElementClassString(), $value);
			0 ignored issues – show Bug introduced 2020-05-25 13:39 UTC by Report Bug Copy Issue Report It seems like `getElementClassString()` 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...
96			}
97
98			/**
99			* Apply conditions to dependents fields.
100			*
101			* @return void
102			*/
103			protected function applyCascadeConditions()
104			{
105			if( $this->form ) {
106			$this->form->fields()
107			->filter(function (Form\Field $field) {
108			return $field instanceof CascadeGroup
109			&& $field->dependsOn($this)
110			&& $this->hitsCondition($field);
111			})->each->visiable();
112			}
113			}
114
115			/**
116			* @param CascadeGroup $group
117			*
118			* @throws \Exception
119			*
120			* @return bool
121			*/
122			protected function hitsCondition(CascadeGroup $group)
123			{
124			$condition = $this->conditions[$group->index()];
125
126			extract($condition);
127
128			$old = old($this->column(), $this->value());
			0 ignored issues – show Bug introduced 2020-05-25 13:39 UTC by Report Bug Copy Issue Report It seems like `column()` 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... Bug introduced 2020-05-25 13:39 UTC by Report Bug Copy Issue Report It seems like `value()` 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...
129
130			switch ($operator) {
131			case '=':
132			return $old == $value;
133			case '>':
134			return $old > $value;
135			case '<':
136			return $old < $value;
137			case '>=':
138			return $old >= $value;
139			case '<=':
140			return $old <= $value;
141			case '!=':
142			return $old != $value;
143			case 'in':
144			return in_array($old, $value);
145			case 'notIn':
146			return !in_array($old, $value);
147			case 'has':
148			return in_array($value, $old);
149			case 'oneIn':
150			return count(array_intersect($value, $old)) >= 1;
151			case 'oneNotIn':
152			return count(array_intersect($value, $old)) == 0;
153			default:
154			throw new \Exception("Operator [$operator] not support.");
155			}
156			}
157
158			/**
159			* Add cascade scripts to contents.
160			*
161			* @return void
162			*/
163			protected function addCascadeScript()
164			{
165			if (empty($this->conditions)) {
166			return;
167			}
168
169			$cascadeGroups = collect($this->conditions)->map(function ($condition) {
170			return [
171			'class' => $this->getCascadeClass($condition['value']),
172			'operator' => $condition['operator'],
173			'value' => $condition['value'],
174			];
175			})->toJson();
176
177			$script = <<<SCRIPT
178			;(function () {
179			var operator_table = {
180			'=': function(a, b) {
181			if ($.isArray(a) && $.isArray(b)) {
182			return $(a).not(b).length === 0 && $(b).not(a).length === 0;
183			}
184
185			return a == b;
186			},
187			'>': function(a, b) { return a > b; },
188			'<': function(a, b) { return a < b; },
189			'>=': function(a, b) { return a >= b; },
190			'<=': function(a, b) { return a <= b; },
191			'!=': function(a, b) {
192			if ($.isArray(a) && $.isArray(b)) {
193			return !($(a).not(b).length === 0 && $(b).not(a).length === 0);
194			}
195
196			return a != b;
197			},
198			'in': function(a, b) { return $.inArray(a, b) != -1; },
199			'notIn': function(a, b) { return $.inArray(a, b) == -1; },
200			'has': function(a, b) { return $.inArray(b, a) != -1; },
201			'oneIn': function(a, b) { return a.filter(v => b.includes(v)).length >= 1; },
202			'oneNotIn': function(a, b) { return a.filter(v => b.includes(v)).length == 0; },
203			};
204			var cascade_groups = {$cascadeGroups};
205			$('{$this->getElementClassSelector()}').on('{$this->cascadeEvent}', function (e) {
			0 ignored issues – show Bug introduced 2020-05-25 13:39 UTC by Report Bug Copy Issue Report The property `cascadeEvent` 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... Bug introduced 2020-05-25 13:39 UTC by Report Bug Copy Issue Report It seems like `getElementClassSelector()` 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...
206
207			{$this->getFormFrontValue()}
208
209			cascade_groups.forEach(function (event) {
210			var group = $('div.cascade-group.'+event.class);
211			if( operator_table[event.operator](checked, event.value) ) {
212			group.removeClass('hide');
213			} else {
214			group.addClass('hide');
215			}
216			});
217			})
218			})();
219			SCRIPT;
220
221			Admin::script($script);
222			}
223
224			/**
225			* @return string
226			*/
227			protected function getFormFrontValue()
228			{
229			switch (get_class($this)) {
230			case Radio::class:
231			case RadioButton::class:
232			case RadioCard::class:
233			case Select::class:
234			case BelongsTo::class:
235			case BelongsToMany::class:
236			case MultipleSelect::class:
237			return 'var checked = $(this).val();';
238			case Checkbox::class:
239			case CheckboxButton::class:
240			case CheckboxCard::class:
241			return <<<SCRIPT
242			var checked = $('{$this->getElementClassSelector()}:checked').map(function(){
			0 ignored issues – show Bug introduced 2020-05-25 13:39 UTC by Report Bug Copy Issue Report It seems like `getElementClassSelector()` 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...
243			return $(this).val();
244			}).get();
245			SCRIPT;
246			default:
247			throw new \InvalidArgumentException('Invalid form field type');
248			}
249			}
250			}
251

z-song / laravel-admin

Push — master ( 303741...88bbbb )

CanCascadeFields A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

9 Methods

Duplication Side-by-Side

Filter issues like