HasOptions::setOptions() - Code Metrics - Inspection of "add form element has options" - ScoLib/admin - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 675c3f...4830ba )

by wen

created 2017-09-20 09:46 UTC

HasOptions::setOptions() A

↳ Parent: HasOptions

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	6
rs	9.4285
cc	1
eloc	3
nc	1
nop	1

<?php

namespace Sco\Admin\Form\Elements\Concerns;

use Illuminate\Database\Eloquent\Model;
use InvalidArgumentException;
use Sco\Admin\Contracts\RepositoryInterface;

trait HasOptions
{
    protected $options = [];

    protected $optionsLabelAttribute;

    protected $optionsValueAttribute;

    protected function isOptionsModel()
    {
        return is_string($this->options) || $this->options instanceof Model;
    }

    protected function isRelation()
    {
        return method_exists($this->getModel(), $this->getName());
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
    }

    public function getOptions()
    {
        if ($this->options instanceof \Closure) {
            $options = ($this->options)();
        } elseif (is_string($this->options) || $this->options instanceof Model) {
            $options = $this->setOptionsFromModel();
        } elseif (is_array($this->options)) {
            $options = $this->options;
        } else {
            throw new InvalidArgumentException(
                sprintf(
                    "The form %s element's options must be return array(key=>value)",
                    $this->getType()
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
                )
            );
        }

        return $this->parseOptions($options);
    }

    protected function parseOptions($options)
    {
        return $options;
    }

    /**
     * @param mixed $options
     *
     * @return $this
     */
    public function setOptions($options)
    {
        $this->options = $options;


        return $this;
    }

    /**
     *
     * @return array
     */
    protected function setOptionsFromModel()
    {
        $model = $this->getOptionsModel();

        $key = $this->getOptionsValueAttribute() ?: $model->getKeyName();

        $repository = app(RepositoryInterface::class);
        $repository->setModel($model);
        $query = $repository->getQuery();

        $results = $query->get();
        if (is_null(($label = $this->getOptionsLabelAttribute()))) {
            throw new InvalidArgumentException(
                sprintf(
                    'Form %s element must set label attribute',
                    $this->getType()
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
                )
            );
        }
        return $results->pluck($this->getOptionsLabelAttribute(), $key);
    }

    /**
     * @return Model
     */
    public function getOptionsModel()
    {
        $model = $this->options;

        if (is_string($model)) {
            $model = app($model);
        }

        if (!($model instanceof Model)) {
            throw new InvalidArgumentException(
                sprintf(
                    'Form %s element options class must be instanced of "%s".',
                    $this->getType(),
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
                    Model::class
                )
            );
        }

        return $model;
    }

    /**
     * 获取 options 标题字段
     *
     * @return string
     */
    public function getOptionsLabelAttribute()
    {
        return $this->optionsLabelAttribute;
    }

    /**
     * 设置 options 标题字段
     *
     * @param string $value
     *
     * @return $this
     */
    public function setOptionsLabelAttribute($value)
    {
        $this->optionsLabelAttribute = $value;

        return $this;
    }

    /**
     * 获取 options value 字段
     *
     * @return string
     */
    public function getOptionsValueAttribute()
    {
        return $this->optionsValueAttribute;
    }

    /**
     * 设置 options value 字段
     *
     * @param string $value
     *
     * @return $this
     */
    public function setOptionsValueAttribute($value)
    {
        $this->optionsValueAttribute = $value;

        return $this;
    }
}


1			<?php
2
3			namespace Sco\Admin\Form\Elements\Concerns;
4
5			use Illuminate\Database\Eloquent\Model;
6			use InvalidArgumentException;
7			use Sco\Admin\Contracts\RepositoryInterface;
8
9			trait HasOptions
10			{
11			protected $options = [];
12
13			protected $optionsLabelAttribute;
14
15			protected $optionsValueAttribute;
16
17			protected function isOptionsModel()
18			{
19			return is_string($this->options) \|\| $this->options instanceof Model;
20			}
21
22			protected function isRelation()
23			{
24			return method_exists($this->getModel(), $this->getName());
			0 ignored issues – show Bug introduced 2017-09-20 09:57 UTC by Report Bug Copy Issue Report It seems like `getModel()` 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 2017-09-20 09:57 UTC by Report Bug Copy Issue Report It seems like `getName()` 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...
25			}
26
27			public function getOptions()
28			{
29			if ($this->options instanceof \Closure) {
30			$options = ($this->options)();
31			} elseif (is_string($this->options) \|\| $this->options instanceof Model) {
32			$options = $this->setOptionsFromModel();
33			} elseif (is_array($this->options)) {
34			$options = $this->options;
35			} else {
36			throw new InvalidArgumentException(
37			sprintf(
38			"The form %s element's options must be return array(key=>value)",
39			$this->getType()
			0 ignored issues – show Bug introduced 2017-09-20 09:57 UTC by Report Bug Copy Issue Report It seems like `getType()` 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...
40			)
41			);
42			}
43
44			return $this->parseOptions($options);
45			}
46
47			protected function parseOptions($options)
48			{
49			return $options;
50			}
51
52			/**
53			* @param mixed $options
54			*
55			* @return $this
56			*/
57			public function setOptions($options)
58			{
59			$this->options = $options;
			0 ignored issues – show Documentation Bug introduced 2017-09-19 09:56 UTC by Report Bug Copy Issue Report It seems like `$options` of type `*` is incompatible with the declared type `array` of property `$options`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
60
61			return $this;
62			}
63
64			/**
65			*
66			* @return array
67			*/
68			protected function setOptionsFromModel()
69			{
70			$model = $this->getOptionsModel();
71
72			$key = $this->getOptionsValueAttribute() ?: $model->getKeyName();
73
74			$repository = app(RepositoryInterface::class);
75			$repository->setModel($model);
76			$query = $repository->getQuery();
77
78			$results = $query->get();
79			if (is_null(($label = $this->getOptionsLabelAttribute()))) {
80			throw new InvalidArgumentException(
81			sprintf(
82			'Form %s element must set label attribute',
83			$this->getType()
			0 ignored issues – show Bug introduced 2017-09-20 09:57 UTC by Report Bug Copy Issue Report It seems like `getType()` 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...
84			)
85			);
86			}
87			return $results->pluck($this->getOptionsLabelAttribute(), $key);
88			}
89
90			/**
91			* @return Model
92			*/
93			public function getOptionsModel()
94			{
95			$model = $this->options;
96
97			if (is_string($model)) {
98			$model = app($model);
99			}
100
101			if (!($model instanceof Model)) {
102			throw new InvalidArgumentException(
103			sprintf(
104			'Form %s element options class must be instanced of "%s".',
105			$this->getType(),
			0 ignored issues – show Bug introduced 2017-09-20 09:57 UTC by Report Bug Copy Issue Report It seems like `getType()` 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...
106			Model::class
107			)
108			);
109			}
110
111			return $model;
112			}
113
114			/**
115			* 获取 options 标题字段
116			*
117			* @return string
118			*/
119			public function getOptionsLabelAttribute()
120			{
121			return $this->optionsLabelAttribute;
122			}
123
124			/**
125			* 设置 options 标题字段
126			*
127			* @param string $value
128			*
129			* @return $this
130			*/
131			public function setOptionsLabelAttribute($value)
132			{
133			$this->optionsLabelAttribute = $value;
134
135			return $this;
136			}
137
138			/**
139			* 获取 options value 字段
140			*
141			* @return string
142			*/
143			public function getOptionsValueAttribute()
144			{
145			return $this->optionsValueAttribute;
146			}
147
148			/**
149			* 设置 options value 字段
150			*
151			* @param string $value
152			*
153			* @return $this
154			*/
155			public function setOptionsValueAttribute($value)
156			{
157			$this->optionsValueAttribute = $value;
158
159			return $this;
160			}
161			}
162

ScoLib / admin

Push — master ( 675c3f...4830ba )

HasOptions::setOptions() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like