Embeds - Code Metrics - Inspection of "Bug Fix for HasMany & EmbeddForm getValidator() Me..." - z-song/laravel-admin - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#2901)

unknown

created 2018-12-29 05:01 UTC

Embeds B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	355
Duplicated Lines	31.83 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

Metric	Value
dl	113
loc	355
rs	8.64
c	0
b	0
f	0
wmc	47
lcom	1
cbo	4

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	13	13	3
A	prepare()	0	6	1
B	formatValidationAttribute()	26	26	8
A	resetInputKey()	16	21	3
A	getEmbeddedData()	0	16	4
A	buildEmbeddedForm()	0	12	1
A	render()	0	4	1
F	getValidator()	58	189	26

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 Embeds 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 Embeds, and based on these observations, apply Extract Interface, too.

<?php

namespace Encore\Admin\Form\Field;

use Encore\Admin\Form\EmbeddedForm;
use Encore\Admin\Form\Field;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Str;

class Embeds extends Field
{
    /**
     * @var \Closure
     */
    protected $builder = null;
    protected $view = 'admin::form.embeds';

    /**
     * Create a new HasMany field instance.
     *
     * @param string $column
     * @param array  $arguments
     */
    public function __construct($column, $arguments = [])

    {
        $this->column = $column;

        if (count($arguments) == 1) {
            $this->label = $this->formatLabel();
            $this->builder = $arguments[0];
        }

        if (count($arguments) == 2) {
            list($this->label, $this->builder) = $arguments;
        }
    }

    /**
     * Prepare input data for insert or update.
     *
     * @param array $input
     *
     * @return array
     */
    public function prepare($input)
    {
        $form = $this->buildEmbeddedForm();

        return $form->setOriginal($this->original)->prepare($input);
    }

    /**
     * {@inheritdoc}
     */
    public function getValidator(array $input)
    {
        if (!array_key_exists($this->column, $input)) {
            return false;
        }

        $input = array_only($input, $this->column);

        $rules = $attributes = $messages = [];
        $rel = $this->column;

        $availInput = $input;
        $array_key_attach_str = function(array $a, string $b, string $c = '.') {

            return call_user_func_array(
                'array_merge',
                array_map(function($u, $v) use ($b, $c) {
                    return ["{$b}{$c}{$u}" => $v];
                }, array_keys($a), array_values($a))
            );
        };

        $array_key_clean = function(array $a) {

            $a = count($a) ? call_user_func_array('array_merge', array_map(function($k, $v) {
                return [str_replace(':', '', $k) => $v];
            }, array_keys($a), array_values($a))) : $a;

            return $a;
        };

        $array_key_clean_undot = function(array $a) {

            $keys = preg_grep('/[\.\:]/', array_keys($a));
            if ($keys) {

                foreach ($keys as $key) {
                    array_set($a, str_replace(':', '', $key), $a[$key]);
                    unset($a[$key]);
                }
            }

            return $a;
        };


        /** @var Field $field */
        foreach ($this->buildEmbeddedForm()->fields() as $field) {
            if (!$fieldRules = $field->getRules()) {
                continue;
            }

            $column = $field->column();
            $columns = is_array($column) ? $column : [$column];
            if ($field instanceof Field\MultipleSelect) {
                $availInput[$column] = array_filter($availInput[$column], 'strlen');
                $availInput[$column] = $availInput[$column] ? : null;
            }
            /*
             *
             * For single column field format rules to:
             * [
             *     'extra.name' => 'required'
             *     'extra.email' => 'required'
             * ]
             *
             * For multiple column field with rules like 'required':
             * 'extra' => [
             *     'start' => 'start_at'
             *     'end'   => 'end_at',
             * ]
             *
             * format rules to:
             * [
             *     'extra.start_atstart' => 'required'
             *     'extra.end_atend' => 'required'
             * ]
             */
            $newColumn = array_map(function($k, $v) use ($rel) {
                //Fix ResetInput Function! A Headache Implementation!
                return !$k ? "{$rel}.{$v}" : "{$rel}.{$v}:{$k}";
            }, array_keys($columns), array_values($columns));

            $fieldRules = is_array($fieldRules) ? implode('|', $fieldRules) : $fieldRules;
            $rules = array_merge($rules, call_user_func_array(
                'array_merge',
                array_map(function($v) use ($fieldRules) {
                    return [$v => $fieldRules];
                }, $newColumn)
            ));
            $attributes = array_merge($attributes, call_user_func_array(
                'array_merge',
                array_map(function($v) use ($field) {

                    //Fix ResetInput Function! A Headache Implementation!
                    $u = $field->label();
                    $u .= is_array($field->column()) ? '['.explode(':', explode('.', $v)[1])[0].']' : '';

                    return [$v => "{$u}"];
                }, $newColumn)
            ));
            if ($field->validationMessages) {

                $newMessages = array_map(function($v) use ($field, $availInput, $array_key_attach_str) {
                    list($rel, $col) = explode('.', $v);
                    //Fix ResetInput Function! A Headache Implementation!
                    $col1 = explode(':', $col)[0];
                    if (!array_key_exists($col1, $availInput[$rel])) {
                        return [null => null];
                    }
                    $rows = $availInput[$rel][$col1];
                    if (!is_array($rows)) {
                        return $array_key_attach_str($field->validationMessages, $v);
                    }
                    $r = [];
                    foreach (array_keys($rows) as $k) {
                        $k = "{$v}{$k}";
                        $r = array_merge($r, $array_key_attach_str($field->validationMessages, $k));
                    }

                    return $r;
                }, $newColumn);
                $newMessages = call_user_func_array('array_merge', $newMessages);
                $messages = array_merge($messages, $newMessages);
            }
        }

        if (empty($rules)) {
            return false;
        }
        $newInput = call_user_func_array('array_merge', array_map(function($idx) use ($availInput) {
            list($rel, $col) = explode('.', $idx);
            //Fix ResetInput Function! A Headache Implementation!
            $col1 = explode(':', $col)[0];
            if (!array_key_exists($col1, $availInput[$rel])) {
                return [null => null];
            }
            if (is_array($availInput[$rel][$col1])) {
                return call_user_func_array('array_merge', array_map(function($x, $y) use ($idx) {
                    return ["{$idx}{$x}" => $y];
                }, array_keys($availInput[$rel][$col1]), $availInput[$rel][$col1]));
            }

            return ["{$idx}" => $availInput[$rel][$col1]];
        }, array_keys($rules)));

        $newInput = $array_key_clean_undot($newInput);
        $newRules = array_map(function($idx) use ($availInput, $rules) {
            list($rel, $col) = explode('.', $idx);
            //Fix ResetInput Function! A Headache Implementation!
            $col1 = explode(':', $col)[0];
            if (!array_key_exists($col1, $availInput[$rel])) {
                return [null => null];
            }
            if (is_array($availInput[$rel][$col1])) {
                return call_user_func_array('array_merge', array_map(function($x) use ($idx, $rules) {
                    return ["{$idx}{$x}" => $rules[$idx]];
                }, array_keys($availInput[$rel][$col1])));
            }

            return ["{$idx}" => $rules[$idx]];
        }, array_keys($rules));
        $newRules = array_filter(call_user_func_array('array_merge', $newRules), 'strlen', ARRAY_FILTER_USE_KEY);
        $newRules = $array_key_clean($newRules);

        $newAttributes = array_map(function($idx) use ($availInput, $attributes) {
            list($rel, $col) = explode('.', $idx);
            //Fix ResetInput Function! A Headache Implementation!
            $col1 = explode(':', $col)[0];
            if (!array_key_exists($col1, $availInput[$rel])) {
                return [null => null];
            }
            if (is_array($availInput[$rel][$col1])) {

                if (array_keys($availInput[$rel][$col1])) {
                    return call_user_func_array('array_merge', array_map(function($x) use ($idx, $attributes) {
                        return ["{$idx}.{$x}" => $attributes[$idx]];
                    }, array_keys($availInput[$rel][$col1])));
                }

                return [null => null];
            }

            return ["{$idx}" => $attributes[$idx]];
        }, array_keys($attributes));
        $newAttributes = array_filter(call_user_func_array('array_merge', $newAttributes), 'strlen');
        $newAttributes = $array_key_clean($newAttributes);

        $messages = $array_key_clean($messages);

        if (empty($newInput)) {
            $newInput = $availInput;
        }

        return Validator::make($newInput, $newRules, $messages, $newAttributes);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * Format validation attributes.
     *
     * @param array  $input
     * @param string $label
     * @param string $column
     *
     * @return array
     */
    protected function formatValidationAttribute($input, $label, $column)

    {
        $new = $attributes = [];

        if (is_array($column)) {
            foreach ($column as $index => $col) {
                $new[$col.$index] = $col;
            }
        }

        foreach (array_keys(array_dot($input)) as $key) {
            if (is_string($column)) {
                if (Str::endsWith($key, ".$column")) {
                    $attributes[$key] = $label;
                }
            } else {
                foreach ($new as $k => $val) {
                    if (Str::endsWith($key, ".$k")) {
                        $attributes[$key] = $label."[$val]";
                    }
                }
            }
        }

        return $attributes;
    }

    /**
     * Reset input key for validation.
     *
     * @param array $input
     * @param array $column $column is the column name array set
     *
     * @return void.

     */
    public function resetInputKey(array &$input, array $column)
    {
        $column = array_flip($column);

        foreach ($input[$this->column] as $key => $value) {

            if (!array_key_exists($key, $column)) {
                continue;
            }

            $newKey = $key.$column[$key];

            /*
             * set new key
             */
            array_set($input, "{$this->column}.$newKey", $value);
            /*
             * forget the old key and value
             */
            array_forget($input, "{$this->column}.$key");
        }
    }

    /**
     * Get data for Embedded form.
     *
     * Normally, data is obtained from the database.
     *
     * When the data validation errors, data is obtained from session flash.
     *
     * @return array
     */
    protected function getEmbeddedData()
    {
        if ($old = old($this->column)) {
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            return $old;
        }

        if (empty($this->value)) {
            return [];
        }

        if (is_string($this->value)) {
            return json_decode($this->value, true);
        }

        return (array)$this->value;
    }

    /**
     * Build a Embedded Form and fill data.
     *
     * @return EmbeddedForm
     */
    protected function buildEmbeddedForm()
    {
        $form = new EmbeddedForm($this->column);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $form->setParent($this->form);

        call_user_func($this->builder, $form);

        $form->fill($this->getEmbeddedData());

        return $form;
    }

    /**
     * Render the form.
     *
     * @return \Illuminate\View\View
     */
    public function render()
    {
        return parent::render()->with(['form' => $this->buildEmbeddedForm()]);
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.
}
    }
}


1		<?php
2
3		namespace Encore\Admin\Form\Field;
4
5		use Encore\Admin\Form\EmbeddedForm;
6		use Encore\Admin\Form\Field;
7		use Illuminate\Support\Facades\Validator;
8		use Illuminate\Support\Str;
9
10		class Embeds extends Field
11		{
12		/**
13		* @var \Closure
14		*/
15		protected $builder = null;
16		protected $view = 'admin::form.embeds';
17
18		/**
19		* Create a new HasMany field instance.
20		*
21		* @param string $column
22		* @param array $arguments
23		*/
24	View Code Duplication	public function __construct($column, $arguments = [])
		0 ignored issues – show Duplication introduced 2017-09-01 02:27 UTC by Report Bug Copy Issue Report This method seems to be duplicated in 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...
25		{
26		$this->column = $column;
27
28		if (count($arguments) == 1) {
29		$this->label = $this->formatLabel();
30		$this->builder = $arguments[0];
31		}
32
33		if (count($arguments) == 2) {
34		list($this->label, $this->builder) = $arguments;
35		}
36		}
37
38		/**
39		* Prepare input data for insert or update.
40		*
41		* @param array $input
42		*
43		* @return array
44		*/
45		public function prepare($input)
46		{
47		$form = $this->buildEmbeddedForm();
48
49		return $form->setOriginal($this->original)->prepare($input);
50		}
51
52		/**
53		* {@inheritdoc}
54		*/
55		public function getValidator(array $input)
56		{
57		if (!array_key_exists($this->column, $input)) {
58		return false;
59		}
60
61		$input = array_only($input, $this->column);
62
63		$rules = $attributes = $messages = [];
64		$rel = $this->column;
65
66		$availInput = $input;
67	View Code Duplication	$array_key_attach_str = function(array $a, string $b, string $c = '.') {
		0 ignored issues – show Duplication introduced 2018-12-29 02:10 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...
68		return call_user_func_array(
69		'array_merge',
70		array_map(function($u, $v) use ($b, $c) {
71		return ["{$b}{$c}{$u}" => $v];
72		}, array_keys($a), array_values($a))
73		);
74		};
75
76	View Code Duplication	$array_key_clean = function(array $a) {
		0 ignored issues – show Duplication introduced 2018-12-29 02:10 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...
77		$a = count($a) ? call_user_func_array('array_merge', array_map(function($k, $v) {
78		return [str_replace(':', '', $k) => $v];
79		}, array_keys($a), array_values($a))) : $a;
80
81		return $a;
82		};
83
84	View Code Duplication	$array_key_clean_undot = function(array $a) {
		0 ignored issues – show Duplication introduced 2018-12-29 02:10 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...
85		$keys = preg_grep('/[\.\:]/', array_keys($a));
86		if ($keys) {
		0 ignored issues – show Bug Best Practice introduced 2018-12-29 05:04 UTC by Report Bug Copy Issue Report The expression `$keys` of type `string[]` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
87		foreach ($keys as $key) {
88		array_set($a, str_replace(':', '', $key), $a[$key]);
89		unset($a[$key]);
90		}
91		}
92
93		return $a;
94		};
95
96
97		/** @var Field $field */
98		foreach ($this->buildEmbeddedForm()->fields() as $field) {
99		if (!$fieldRules = $field->getRules()) {
100		continue;
101		}
102
103		$column = $field->column();
104		$columns = is_array($column) ? $column : [$column];
105		if ($field instanceof Field\MultipleSelect) {
106		$availInput[$column] = array_filter($availInput[$column], 'strlen');
107		$availInput[$column] = $availInput[$column] ? : null;
108		}
109		/*
110		*
111		* For single column field format rules to:
112		* [
113		* 'extra.name' => 'required'
114		* 'extra.email' => 'required'
115		* ]
116		*
117		* For multiple column field with rules like 'required':
118		* 'extra' => [
119		* 'start' => 'start_at'
120		* 'end' => 'end_at',
121		* ]
122		*
123		* format rules to:
124		* [
125		* 'extra.start_atstart' => 'required'
126		* 'extra.end_atend' => 'required'
127		* ]
128		*/
129		$newColumn = array_map(function($k, $v) use ($rel) {
130		//Fix ResetInput Function! A Headache Implementation!
131		return !$k ? "{$rel}.{$v}" : "{$rel}.{$v}:{$k}";
132		}, array_keys($columns), array_values($columns));
133
134		$fieldRules = is_array($fieldRules) ? implode('\|', $fieldRules) : $fieldRules;
135		$rules = array_merge($rules, call_user_func_array(
136		'array_merge',
137		array_map(function($v) use ($fieldRules) {
138		return [$v => $fieldRules];
139		}, $newColumn)
140		));
141		$attributes = array_merge($attributes, call_user_func_array(
142		'array_merge',
143	View Code Duplication	array_map(function($v) use ($field) {
		0 ignored issues – show Duplication introduced 2018-12-29 02:10 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...
144		//Fix ResetInput Function! A Headache Implementation!
145		$u = $field->label();
146		$u .= is_array($field->column()) ? '['.explode(':', explode('.', $v)[1])[0].']' : '';
147
148		return [$v => "{$u}"];
149		}, $newColumn)
150		));
151	View Code Duplication	if ($field->validationMessages) {
		0 ignored issues – show Duplication introduced 2018-12-29 02:10 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...
152		$newMessages = array_map(function($v) use ($field, $availInput, $array_key_attach_str) {
153		list($rel, $col) = explode('.', $v);
154		//Fix ResetInput Function! A Headache Implementation!
155		$col1 = explode(':', $col)[0];
156		if (!array_key_exists($col1, $availInput[$rel])) {
157		return [null => null];
158		}
159		$rows = $availInput[$rel][$col1];
160		if (!is_array($rows)) {
161		return $array_key_attach_str($field->validationMessages, $v);
162		}
163		$r = [];
164		foreach (array_keys($rows) as $k) {
165		$k = "{$v}{$k}";
166		$r = array_merge($r, $array_key_attach_str($field->validationMessages, $k));
167		}
168
169		return $r;
170		}, $newColumn);
171		$newMessages = call_user_func_array('array_merge', $newMessages);
172		$messages = array_merge($messages, $newMessages);
173		}
174		}
175
176		if (empty($rules)) {
177		return false;
178		}
179		$newInput = call_user_func_array('array_merge', array_map(function($idx) use ($availInput) {
180		list($rel, $col) = explode('.', $idx);
181		//Fix ResetInput Function! A Headache Implementation!
182		$col1 = explode(':', $col)[0];
183		if (!array_key_exists($col1, $availInput[$rel])) {
184		return [null => null];
185		}
186		if (is_array($availInput[$rel][$col1])) {
187		return call_user_func_array('array_merge', array_map(function($x, $y) use ($idx) {
188		return ["{$idx}{$x}" => $y];
189		}, array_keys($availInput[$rel][$col1]), $availInput[$rel][$col1]));
190		}
191
192		return ["{$idx}" => $availInput[$rel][$col1]];
193		}, array_keys($rules)));
194
195		$newInput = $array_key_clean_undot($newInput);
196		$newRules = array_map(function($idx) use ($availInput, $rules) {
197		list($rel, $col) = explode('.', $idx);
198		//Fix ResetInput Function! A Headache Implementation!
199		$col1 = explode(':', $col)[0];
200		if (!array_key_exists($col1, $availInput[$rel])) {
201		return [null => null];
202		}
203		if (is_array($availInput[$rel][$col1])) {
204		return call_user_func_array('array_merge', array_map(function($x) use ($idx, $rules) {
205		return ["{$idx}{$x}" => $rules[$idx]];
206		}, array_keys($availInput[$rel][$col1])));
207		}
208
209		return ["{$idx}" => $rules[$idx]];
210		}, array_keys($rules));
211		$newRules = array_filter(call_user_func_array('array_merge', $newRules), 'strlen', ARRAY_FILTER_USE_KEY);
212		$newRules = $array_key_clean($newRules);
213
214		$newAttributes = array_map(function($idx) use ($availInput, $attributes) {
215		list($rel, $col) = explode('.', $idx);
216		//Fix ResetInput Function! A Headache Implementation!
217		$col1 = explode(':', $col)[0];
218		if (!array_key_exists($col1, $availInput[$rel])) {
219		return [null => null];
220		}
221	View Code Duplication	if (is_array($availInput[$rel][$col1])) {
		0 ignored issues – show Duplication introduced 2018-12-29 02:10 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...
222		if (array_keys($availInput[$rel][$col1])) {
223		return call_user_func_array('array_merge', array_map(function($x) use ($idx, $attributes) {
224		return ["{$idx}.{$x}" => $attributes[$idx]];
225		}, array_keys($availInput[$rel][$col1])));
226		}
227
228		return [null => null];
229		}
230
231		return ["{$idx}" => $attributes[$idx]];
232		}, array_keys($attributes));
233		$newAttributes = array_filter(call_user_func_array('array_merge', $newAttributes), 'strlen');
234		$newAttributes = $array_key_clean($newAttributes);
235
236		$messages = $array_key_clean($messages);
237
238		if (empty($newInput)) {
239		$newInput = $availInput;
240		}
241
242		return Validator::make($newInput, $newRules, $messages, $newAttributes);
		0 ignored issues – show Bug Best Practice introduced 2018-12-29 02:10 UTC by Report Bug Copy Issue Report The return type of `return \Illuminate\Suppo...sages, $newAttributes);` (`Illuminate\Contracts\Validation\Validator`) is incompatible with the return type of the parent method `Encore\Admin\Form\Field::getValidator` of type `boolean\|Illuminate\Support\Facades\Validator`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
243		}
244
245		/**
246		* Format validation attributes.
247		*
248		* @param array $input
249		* @param string $label
250		* @param string $column
251		*
252		* @return array
253		*/
254	View Code Duplication	protected function formatValidationAttribute($input, $label, $column)
		0 ignored issues – show Duplication introduced 2017-09-01 02:27 UTC by Report Bug Copy Issue Report This method seems to be duplicated in 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...
255		{
256		$new = $attributes = [];
257
258		if (is_array($column)) {
259		foreach ($column as $index => $col) {
260		$new[$col.$index] = $col;
261		}
262		}
263
264		foreach (array_keys(array_dot($input)) as $key) {
265		if (is_string($column)) {
266		if (Str::endsWith($key, ".$column")) {
267		$attributes[$key] = $label;
268		}
269		} else {
270		foreach ($new as $k => $val) {
271		if (Str::endsWith($key, ".$k")) {
272		$attributes[$key] = $label."[$val]";
273		}
274		}
275		}
276		}
277
278		return $attributes;
279		}
280
281		/**
282		* Reset input key for validation.
283		*
284		* @param array $input
285		* @param array $column $column is the column name array set
286		*
287		* @return void.
		0 ignored issues – show Documentation introduced 2017-09-01 02:27 UTC by Report Bug Copy Issue Report The doc-type `void.` could not be parsed: Unknown type name "void." at position 0. (view supported doc-types) This check marks PHPDoc comments that could not be parsed by our parser. To see which comment annotations we can parse, please refer to our documentation on supported doc-types. Loading history...
288		*/
289		public function resetInputKey(array &$input, array $column)
290		{
291		$column = array_flip($column);
292
293	View Code Duplication	foreach ($input[$this->column] as $key => $value) {
		0 ignored issues – show Duplication introduced 2017-09-01 02:27 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...
294		if (!array_key_exists($key, $column)) {
295		continue;
296		}
297
298		$newKey = $key.$column[$key];
299
300		/*
301		* set new key
302		*/
303		array_set($input, "{$this->column}.$newKey", $value);
304		/*
305		* forget the old key and value
306		*/
307		array_forget($input, "{$this->column}.$key");
308		}
309		}
310
311		/**
312		* Get data for Embedded form.
313		*
314		* Normally, data is obtained from the database.
315		*
316		* When the data validation errors, data is obtained from session flash.
317		*
318		* @return array
319		*/
320		protected function getEmbeddedData()
321		{
322		if ($old = old($this->column)) {
		0 ignored issues – show Bug introduced 2017-09-19 15:53 UTC by Report Bug Copy Issue Report It seems like `$this->column` can also be of type `array`; however, `old()` does only seem to accept `string\|null`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
323		return $old;
324		}
325
326		if (empty($this->value)) {
327		return [];
328		}
329
330		if (is_string($this->value)) {
331		return json_decode($this->value, true);
332		}
333
334		return (array)$this->value;
335		}
336
337		/**
338		* Build a Embedded Form and fill data.
339		*
340		* @return EmbeddedForm
341		*/
342		protected function buildEmbeddedForm()
343		{
344		$form = new EmbeddedForm($this->column);
		0 ignored issues – show Bug introduced 2017-09-19 15:53 UTC by Report Bug Copy Issue Report It seems like `$this->column` can also be of type `array`; however, `Encore\Admin\Form\EmbeddedForm::__construct()` does only seem to accept `string`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
345
346		$form->setParent($this->form);
347
348		call_user_func($this->builder, $form);
349
350		$form->fill($this->getEmbeddedData());
351
352		return $form;
353		}
354
355		/**
356		* Render the form.
357		*
358		* @return \Illuminate\View\View
359		*/
360		public function render()
361		{
362		return parent::render()->with(['form' => $this->buildEmbeddedForm()]);
		0 ignored issues – show Bug introduced 2017-09-01 02:27 UTC by Report Bug Copy Issue Report The method `with` does only exist in `Illuminate\View\View`, but not in `Illuminate\Contracts\View\Factory`. 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...
363		}
364		}
365

z-song / laravel-admin