ActiveRecord - Code Metrics - Inspection of "csfixed" - hiqdev/yii2-hiart - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 7b0605...a35aa7 )

by Andrii

created 2017-10-13 16:31 UTC

ActiveRecord B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	303
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

18.87%

Importance

Changes	1
Bugs	1	Features	0

Metric	Value
wmc	43
lcom	1
cbo	8
dl	0
loc	303
ccs	20
cts	106
cp	0.1887
rs	8.3157
c	1
b	1
f	0

24 Methods

Rating	Name	Size	Complexity
A	getDb()	4	1
A	find()	6	1
A	isScenarioDefault()	4	1
A	primaryKey()	4	1
B	attributes()	18	5
A	tableName()	4	1
A	modelName()	4	1
B	insert()	25	5
A	delete()	14	3
A	update()	8	3
B	updateInternal()	25	5
A	instantiate()	4	1
A	getScenarioAction()	14	4
A	scenarioActions()	4	1
A	getIsNewRecord()	4	1
A	optimisticLock()	4	1
A	unlinkAll()	4	1
A	getRelation()	4	1
A	batchQuery()	6	1
A	query()	6	1
A	batchPerform()	6	1
A	perform()	4	1
A	hasOne()	4	1
A	hasMany()	4	1

How to fix Complexity

<?php
/**
 * ActiveRecord for API
 *
 * @link      https://github.com/hiqdev/yii2-hiart
 * @package   yii2-hiart
 * @license   BSD-3-Clause
 * @copyright Copyright (c) 2015-2017, HiQDev (http://hiqdev.com/)
 */

namespace hiqdev\hiart;

use yii\base\InvalidConfigException;
use yii\base\NotSupportedException;
use yii\db\ActiveQueryInterface;
use yii\db\BaseActiveRecord;
use yii\helpers\Inflector;
use yii\helpers\StringHelper;

class ActiveRecord extends BaseActiveRecord
{
    /**
     * Returns the database connection used by this AR class.
     * By default, the "hiart" application component is used as the database connection.
     * You may override this method if you want to use a different database connection.
     *
     * @return AbstractConnection the database connection used by this AR class
     */
    public static function getDb()
    {
        return AbstractConnection::getDb();
    }

    /**
     * {@inheritdoc}
     * @return ActiveQuery the newly created [[ActiveQuery]] instance
     */
    public static function find()
    {
        $class = static::getDb()->activeQueryClass;

        return new $class(get_called_class());
    }

    public function isScenarioDefault()
    {
        return $this->scenario === static::SCENARIO_DEFAULT;
    }

    /**
     * This method defines the attribute that uniquely identifies a record.
     *
     * The primaryKey for HiArt objects is the `id` field by default. This field is not part of the
     * ActiveRecord attributes so you should never add `_id` to the list of [[attributes()|attributes]].
     *
     * You may override this method to define the primary key name.
     *
     * Note that HiArt only supports _one_ attribute to be the primary key. However to match the signature
     * of the [[\yii\db\ActiveRecordInterface|ActiveRecordInterface]] this methods returns an array instead of a
     * single string.
     *
     * @return string[] array of primary key attributes. Only the first element of the array will be used.
     */
    public static function primaryKey()
    {
        return ['id'];
    }

    /**
     * Returns the list of attribute names.
     * By default, this method returns all attributes mentioned in rules.
     * You may override this method to change the default behavior.
     * @return string[] list of attribute names
     */
    public function attributes()
    {
        $attributes = [];
        foreach ($this->rules() as $rule) {
            $names = reset($rule);
            if (is_string($names)) {
                $names = [$names];
            }
            foreach ($names as $name) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
                if (substr_compare($name, '!', 0, 1) === 0) {
                    $name = mb_substr($name, 1);
                }
                $attributes[$name] = $name;
            }
        }

        return array_values($attributes);
    }

    /**
     * Creates an active record instance.
     *
     * This method is called together with [[populateRecord()]] by [[ActiveQuery]].
     * It is not meant to be used for creating new records directly.
     *
     * You may override this method if the instance being created
     * depends on the row data to be populated into the record.
     * For example, by creating a record based on the value of a column,
     * you may implement the so-called single-table inheritance mapping.
     *
     * @return static the newly created active record
     */
    public static function instantiate($row)
    {
        return new static();
    }

    /**
     * @return string the name of the entity of this record
     */
    public static function tableName()
    {
        return Inflector::camel2id(StringHelper::basename(get_called_class()), '-');
    }

    /**
     * Declares the name of the model associated with this class.
     * By default this method returns the class name by calling [[Inflector::camel2id()]].
     *
     * @return string the module name
     */
    public static function modelName()
    {
        return Inflector::camel2id(StringHelper::basename(get_called_class()));
    }

    public function insert($runValidation = true, $attributes = null, $options = [])
    {
        if ($runValidation && !$this->validate($attributes)) {
            return false;
        }

        if (!$this->beforeSave(true)) {
            return false;
        }

        $values = $this->getDirtyAttributes($attributes);

        $data   = array_merge($values, $options, ['id' => $this->getOldPrimaryKey()]);
        $result = $this->query('insert', $data);

        $pk        = static::primaryKey()[0];
        $this->$pk = $result['id'];
        if ($pk !== 'id') {
            $values[$pk] = $result['id'];
        }
        $changedAttributes = array_fill_keys(array_keys($values), null);
        $this->setOldAttributes($values);
        $this->afterSave(true, $changedAttributes);

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function delete($options = [])
    {
        if (!$this->beforeDelete()) {
            return false;
        }

        $data   = array_merge($options, ['id' => $this->getOldPrimaryKey()]);
        $result = $this->query('delete', $data);

        $this->setOldAttributes(null);
        $this->afterDelete();

        return $result === false ? false : true;
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());
}
    }

    public function update($runValidation = true, $attributeNames = null, $options = [])
    {
        if ($runValidation && !$this->validate($attributeNames)) {
            return false;
        }

        return $this->updateInternal($attributeNames, $options);

    }

    protected function updateInternal($attributes = null, $options = [])
    {
        if (!$this->beforeSave(false)) {
            return false;
        }

        $values = $this->getAttributes($attributes);
        if (empty($values)) {
            $this->afterSave(false, $values);

            return 0;
        }

        $result = $this->query('update', $values, $options);

        $changedAttributes = [];
        foreach ($values as $name => $value) {
            $changedAttributes[$name] = $this->getOldAttribute($name);
            $this->setOldAttribute($name, $value);
        }

        $this->afterSave(false, $changedAttributes);

        return $result === false ? false : true;
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());
}
    }

    public function batchQuery($defaultScenario, $data = [], array $options = [])
    {
        $options['batch'] = true;

        return $this->query($defaultScenario, $data, $options);
    }

    public function query($defaultScenario, $data = [], array $options = [])
    {
        $action = $this->getScenarioAction($defaultScenario);

        return static::perform($action, $data, $options);
    }

    public static function batchPerform($action, $data = [], array $options = [])
    {
        $options['batch'] = true;

        return static::perform($action, $data, $options);
    }

    public static function perform($action, $data = [], array $options = [])
    {
        return static::getDb()->createCommand()->perform($action, static::tableName(), $data, $options)->getData();
    }

    /**
     * Converts scenario name to action.
     * @param string $default default action name
     * @throws InvalidConfigException
     * @throws NotSupportedException
     * @return string
     */
    public function getScenarioAction($default = '')
    {
        if ($this->isScenarioDefault()) {
            if (empty($default)) {
                throw new InvalidConfigException('Scenario not specified');
            }

            return $default;
        } else {
            $actions = static::scenarioActions();

            return isset($actions[$this->scenario]) ? $actions[$this->scenario] : $this->scenario;
        }
    }

    /**
     * Provides a correspondance array: scenario -> API action.
     * E.g. ['update-name' => 'set-name'].
     * @return array
     */
    public function scenarioActions()
    {
        return [];
    }

    /**
     * @return bool
     */
    public function getIsNewRecord()
    {
        return !$this->getPrimaryKey();
    }

    /**
     * This method has no effect in HiArt ActiveRecord.
     */
    public function optimisticLock()
    {
        return null;
    }

    /**
     * Destroys the relationship in current model.
     *
     * This method is not supported by HiArt.
     */
    public function unlinkAll($name, $delete = false)
    {
        throw new NotSupportedException('unlinkAll() is not supported by HiArt, use unlink() instead.');
    }

    /**
     * {@inheritdoc}
     *
     * @return ActiveQueryInterface|ActiveQuery the relational query object. If the relation does not exist
     *                                          and `$throwException` is false, null will be returned.
     */
    public function getRelation($name, $throwException = true)
    {
        return parent::getRelation($name, $throwException);
    }

    /**
     * {@inheritdoc}
     * @return ActiveQuery the relational query object
     */
    public function hasOne($class, $link)
    {
        return parent::hasOne($class, $link);
    }

    /**
     * {@inheritdoc}
     * @return ActiveQuery the relational query object
     */
    public function hasMany($class, $link)
    {
        return parent::hasMany($class, $link);
    }
}


1		<?php
2		/**
3		* ActiveRecord for API
4		*
5		* @link https://github.com/hiqdev/yii2-hiart
6		* @package yii2-hiart
7		* @license BSD-3-Clause
8		* @copyright Copyright (c) 2015-2017, HiQDev (http://hiqdev.com/)
9		*/
10
11		namespace hiqdev\hiart;
12
13		use yii\base\InvalidConfigException;
14		use yii\base\NotSupportedException;
15		use yii\db\ActiveQueryInterface;
16		use yii\db\BaseActiveRecord;
17		use yii\helpers\Inflector;
18		use yii\helpers\StringHelper;
19
20		class ActiveRecord extends BaseActiveRecord
21		{
22		/**
23		* Returns the database connection used by this AR class.
24		* By default, the "hiart" application component is used as the database connection.
25		* You may override this method if you want to use a different database connection.
26		*
27		* @return AbstractConnection the database connection used by this AR class
28		*/
29		public static function getDb()
30		{
31		return AbstractConnection::getDb();
32		}
33
34		/**
35		* {@inheritdoc}
36		* @return ActiveQuery the newly created [[ActiveQuery]] instance
37		*/
38	2	public static function find()
39		{
40	2	$class = static::getDb()->activeQueryClass;
41
42	2	return new $class(get_called_class());
43		}
44
45		public function isScenarioDefault()
46		{
47		return $this->scenario === static::SCENARIO_DEFAULT;
48		}
49
50		/**
51		* This method defines the attribute that uniquely identifies a record.
52		*
53		* The primaryKey for HiArt objects is the `id` field by default. This field is not part of the
54		* ActiveRecord attributes so you should never add `_id` to the list of [[attributes()\|attributes]].
55		*
56		* You may override this method to define the primary key name.
57		*
58		* Note that HiArt only supports _one_ attribute to be the primary key. However to match the signature
59		* of the [[\yii\db\ActiveRecordInterface\|ActiveRecordInterface]] this methods returns an array instead of a
60		* single string.
61		*
62		* @return string[] array of primary key attributes. Only the first element of the array will be used.
63		*/
64		public static function primaryKey()
65		{
66		return ['id'];
67		}
68
69		/**
70		* Returns the list of attribute names.
71		* By default, this method returns all attributes mentioned in rules.
72		* You may override this method to change the default behavior.
73		* @return string[] list of attribute names
74		*/
75	2	public function attributes()
76		{
77	2	$attributes = [];
78	2	foreach ($this->rules() as $rule) {
79	2	$names = reset($rule);
80	2	if (is_string($names)) {
81	2	$names = [$names];
82	2	}
83	2	foreach ($names as $name) {
		0 ignored issues – show Bug introduced 2017-01-24 17:39 UTC by Report Bug Copy Issue Report The expression `$names` of type `object\|integer\|double\|null\|array\|boolean` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
84	2	if (substr_compare($name, '!', 0, 1) === 0) {
85		$name = mb_substr($name, 1);
86		}
87	2	$attributes[$name] = $name;
88	2	}
89	2	}
90
91	2	return array_values($attributes);
92		}
93
94		/**
95		* Creates an active record instance.
96		*
97		* This method is called together with [[populateRecord()]] by [[ActiveQuery]].
98		* It is not meant to be used for creating new records directly.
99		*
100		* You may override this method if the instance being created
101		* depends on the row data to be populated into the record.
102		* For example, by creating a record based on the value of a column,
103		* you may implement the so-called single-table inheritance mapping.
104		*
105		* @return static the newly created active record
106		*/
107	2	public static function instantiate($row)
108		{
109	2	return new static();
110		}
111
112		/**
113		* @return string the name of the entity of this record
114		*/
115	2	public static function tableName()
116		{
117	2	return Inflector::camel2id(StringHelper::basename(get_called_class()), '-');
118		}
119
120		/**
121		* Declares the name of the model associated with this class.
122		* By default this method returns the class name by calling [[Inflector::camel2id()]].
123		*
124		* @return string the module name
125		*/
126		public static function modelName()
127		{
128		return Inflector::camel2id(StringHelper::basename(get_called_class()));
129		}
130
131		public function insert($runValidation = true, $attributes = null, $options = [])
132		{
133		if ($runValidation && !$this->validate($attributes)) {
134		return false;
135		}
136
137		if (!$this->beforeSave(true)) {
138		return false;
139		}
140
141		$values = $this->getDirtyAttributes($attributes);
		0 ignored issues – show Bug introduced 2016-02-09 16:48 UTC by Report Bug Copy Issue Report It seems like `$attributes` defined by parameter `$attributes` on line 131 can also be of type `array`; however, `yii\db\BaseActiveRecord::getDirtyAttributes()` does only seem to accept `array<integer,string>\|null`, maybe add an additional type check? This check looks at variables that have been passed in as parameters and are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history...
142		$data = array_merge($values, $options, ['id' => $this->getOldPrimaryKey()]);
143		$result = $this->query('insert', $data);
144
145		$pk = static::primaryKey()[0];
146		$this->$pk = $result['id'];
147		if ($pk !== 'id') {
148		$values[$pk] = $result['id'];
149		}
150		$changedAttributes = array_fill_keys(array_keys($values), null);
151		$this->setOldAttributes($values);
152		$this->afterSave(true, $changedAttributes);
153
154		return true;
155		}
156
157		/**
158		* {@inheritdoc}
159		*/
160		public function delete($options = [])
161		{
162		if (!$this->beforeDelete()) {
163		return false;
164		}
165
166		$data = array_merge($options, ['id' => $this->getOldPrimaryKey()]);
167		$result = $this->query('delete', $data);
168
169		$this->setOldAttributes(null);
170		$this->afterDelete();
171
172		return $result === false ? false : true;
		0 ignored issues – show Bug Best Practice introduced 2016-08-17 12:55 UTC by Report Bug Copy Issue Report The return type of `return $result === false ? false : true;` (`boolean`) is incompatible with the return type of the parent method `yii\db\BaseActiveRecord::delete` of type `integer\|false`. 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...
173		}
174
175		public function update($runValidation = true, $attributeNames = null, $options = [])
176		{
177		if ($runValidation && !$this->validate($attributeNames)) {
178		return false;
179		}
180
181		return $this->updateInternal($attributeNames, $options);
		0 ignored issues – show Bug Compatibility introduced 2016-05-12 07:20 UTC by Report Bug Copy Issue Report The expression `$this->updateInternal($attributeNames, $options);` of type `integer\|boolean` adds the type `boolean` to the return on line 181 which is incompatible with the return type of the parent method `yii\db\BaseActiveRecord::update` of type `false\|integer`. Loading history...
182		}
183
184		protected function updateInternal($attributes = null, $options = [])
185		{
186		if (!$this->beforeSave(false)) {
187		return false;
188		}
189
190		$values = $this->getAttributes($attributes);
191		if (empty($values)) {
192		$this->afterSave(false, $values);
193
194		return 0;
195		}
196
197		$result = $this->query('update', $values, $options);
198
199		$changedAttributes = [];
200		foreach ($values as $name => $value) {
201		$changedAttributes[$name] = $this->getOldAttribute($name);
202		$this->setOldAttribute($name, $value);
203		}
204
205		$this->afterSave(false, $changedAttributes);
206
207		return $result === false ? false : true;
		0 ignored issues – show Bug Best Practice introduced 2016-05-12 07:20 UTC by Report Bug Copy Issue Report The return type of `return $result === false ? false : true;` (`boolean`) is incompatible with the return type of the parent method `yii\db\BaseActiveRecord::updateInternal` of type `false\|integer`. 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...
208		}
209
210		public function batchQuery($defaultScenario, $data = [], array $options = [])
211		{
212		$options['batch'] = true;
213
214		return $this->query($defaultScenario, $data, $options);
215		}
216
217		public function query($defaultScenario, $data = [], array $options = [])
218		{
219		$action = $this->getScenarioAction($defaultScenario);
220
221		return static::perform($action, $data, $options);
222		}
223
224		public static function batchPerform($action, $data = [], array $options = [])
225		{
226		$options['batch'] = true;
227
228		return static::perform($action, $data, $options);
229		}
230
231		public static function perform($action, $data = [], array $options = [])
232		{
233		return static::getDb()->createCommand()->perform($action, static::tableName(), $data, $options)->getData();
234		}
235
236		/**
237		* Converts scenario name to action.
238		* @param string $default default action name
239		* @throws InvalidConfigException
240		* @throws NotSupportedException
241		* @return string
242		*/
243		public function getScenarioAction($default = '')
244		{
245		if ($this->isScenarioDefault()) {
246		if (empty($default)) {
247		throw new InvalidConfigException('Scenario not specified');
248		}
249
250		return $default;
251		} else {
252		$actions = static::scenarioActions();
253
254		return isset($actions[$this->scenario]) ? $actions[$this->scenario] : $this->scenario;
255		}
256		}
257
258		/**
259		* Provides a correspondance array: scenario -> API action.
260		* E.g. ['update-name' => 'set-name'].
261		* @return array
262		*/
263		public function scenarioActions()
264		{
265		return [];
266		}
267
268		/**
269		* @return bool
270		*/
271		public function getIsNewRecord()
272		{
273		return !$this->getPrimaryKey();
274		}
275
276		/**
277		* This method has no effect in HiArt ActiveRecord.
278		*/
279		public function optimisticLock()
280		{
281		return null;
282		}
283
284		/**
285		* Destroys the relationship in current model.
286		*
287		* This method is not supported by HiArt.
288		*/
289		public function unlinkAll($name, $delete = false)
290		{
291		throw new NotSupportedException('unlinkAll() is not supported by HiArt, use unlink() instead.');
292		}
293
294		/**
295		* {@inheritdoc}
296		*
297		* @return ActiveQueryInterface\|ActiveQuery the relational query object. If the relation does not exist
298		* and `$throwException` is false, null will be returned.
299		*/
300		public function getRelation($name, $throwException = true)
301		{
302		return parent::getRelation($name, $throwException);
303		}
304
305		/**
306		* {@inheritdoc}
307		* @return ActiveQuery the relational query object
308		*/
309		public function hasOne($class, $link)
310		{
311		return parent::hasOne($class, $link);
312		}
313
314		/**
315		* {@inheritdoc}
316		* @return ActiveQuery the relational query object
317		*/
318		public function hasMany($class, $link)
319		{
320		return parent::hasMany($class, $link);
321		}
322		}
323

hiqdev / yii2-hiart

Push — master ( 7b0605...a35aa7 )

ActiveRecord B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

24 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like