hiqdev\hiart\ActiveRecord

Complexity

Total Complexity

56

Size/Duplication

Total Lines	428
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

0%

Importance

Changes	6
Bugs	1	Features	1

28 Methods

Rating	Name	Duplication	Size	Complexity
A	getDb()	0	4	1
A	find()	0	6	1
A	prepare()	0	3	1
A	isScenarioDefault()	0	4	1
A	get()	0	18	3
A	primaryKey()	0	4	1
A	primaryValue()	0	4	1
A	getPrimaryValue()	0	14	3
B	attributes()	0	18	5
A	index()	0	5	1
A	joinIndex()	0	4	1
A	instantiate()	0	4	1
A	from()	0	4	1
A	modelName()	0	4	1
B	insert()	0	25	5
A	delete()	0	14	3
A	update()	0	8	3
B	updateInternal()	0	25	5
A	performScenario()	0	6	1
A	perform()	0	4	1
D	getScenarioAction()	0	29	9
A	scenarioCommands()	0	4	1
A	getIsNewRecord()	0	4	1
A	optimisticLock()	0	4	1
A	unlinkAll()	0	4	1
A	getRelation()	0	4	1
A	hasOne()	0	4	1
A	hasMany()	0	4	1

<?php
/**
 * Tools to use API as ActiveRecord for Yii2
 *
 * @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 hiqdev\hiart\AbstractConnection;
use yii\base\InvalidConfigException;
use yii\base\NotSupportedException;
use yii\db\ActiveQueryInterface;
use yii\db\BaseActiveRecord;
use yii\helpers\ArrayHelper;
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 Connection 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;

Accessing activeQueryClass on the interface hiqdev\hiart\ConnectionInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        return new $class(get_called_class());
    }

    /**
     * This function is called from `Query::prepare`.
     * You can redefine it to get desired behavior.
     */
    public static function prepare(Query $query, QueryBuilderInterface $builder)

The parameter $query is not used and could be removed.

The parameter $builder is not used and could be removed.

    {
    }

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

    /**
     * Gets a record by its primary key.
     *
     * @param mixed $primaryKey the primaryKey value
     * @param array $options    options given in this parameter are passed to API
     *
     * @return null|static the record instance or null if it was not found
     */
    public static function get($primaryKey = null, $options = [])
    {
        if ($primaryKey === null) {
            return null;
        }
        $command = static::getDb()->createCommand();

It seems like you code against a concrete implementation and not the interface hiqdev\hiart\ConnectionInterface as the method createCommand() does only exist in the following implementations of said interface: hiqdev\hiart\AbstractConnection, hiqdev\hiart\rest\Connection.

        $result  = $command->get(static::from(), $primaryKey, $options);

        if ($result) {
            $model = static::instantiate($result);
            static::populateRecord($model, $result);
            $model->afterFind();

            return $model;
        }

        return null;
    }

    /**
     * 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'];
    }

    /**
     * +     * The name of the main attribute
     * +     *
     * Examples:.
     *
     * This will directly reference to the attribute 'name'
     * ```
     *     return 'name';
     * ```
     *
     * This will concatenate listed attributes, separated with `delimiter` value.
     * If delimiter is not set, space is used by default.
     * ```
     *     return ['seller', 'client', 'delimiter' => '/'];
     * ```
     *
     * The callable method, that will get [[$model]] and should return value of name attribute
     * ```
     *     return function ($model) {
     *        return $model->someField ? $model->name : $model->otherName;
     *     };
     * ```
     *
     * @throws InvalidConfigException
     *
     * @return string|callable|array
     *
     * @author SilverFire
     */
    public function primaryValue()
    {
        return static::formName();
    }

    /**
     * Returns the value of the primary attribute.
     *
     * @throws InvalidConfigException
     *
     * @return mixed|null
     *
     * @see primaryValue()
     */
    public function getPrimaryValue()
    {
        $primaryValue = $this->primaryValue();

        if ($primaryValue instanceof \Closure) {
            return call_user_func($primaryValue, [$this]);
        } elseif (is_array($primaryValue)) {
            $delimiter = ArrayHelper::remove($primaryValue, 'delimiter', ' ');

            return implode($delimiter, $this->getAttributes($primaryValue));
        } else {
            return $this->getAttribute($primaryValue);
        }
    }

    /**
     * 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) {

The expression $names of type object|integer|double|null|array|boolean is not guaranteed to be traversable. How about adding an additional type check?

                if (substr_compare($name, '!', 0, 1) === 0) {
                    $name = mb_substr($name, 1);
                }
                $attributes[$name] = $name;
            }
        }

        return array_values($attributes);
    }

    /**
     * @return string the name of the index this record is stored in
     */
    public static function index()
    {
        //        return Inflector::pluralize(Inflector::camel2id(StringHelper::basename(get_called_class()), '-'));

60% of this comment could be valid code. Did you maybe forget this after debugging?

        return mb_strtolower(StringHelper::basename(get_called_class()) . 's');
    }

    public static function joinIndex()
    {
        return static::index();
    }

    /**
     * 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 from()
    {
        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);

It seems like $attributes defined by parameter $attributes on line 240 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?

        $data   = array_merge($values, $options, ['id' => $this->getOldPrimaryKey()]);
        $result = $this->performScenario('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->performScenario('delete', $data);

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

        return $result === false ? false : true;

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.

    }

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

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

The expression $this->updateInternal($attributeNames, $options); of type integer|boolean adds the type boolean to the return on line 290 which is incompatible with the return type of the parent method yii\db\BaseActiveRecord::update of type false|integer.

    }

    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->performScenario('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;

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.

    }

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

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

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

It seems like you code against a concrete implementation and not the interface hiqdev\hiart\ConnectionInterface as the method createCommand() does only exist in the following implementations of said interface: hiqdev\hiart\AbstractConnection, hiqdev\hiart\rest\Connection.

    }

    /**
     * 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 ($default !== '') {
                $result = Inflector::id2camel($default);
            } else {
                throw new InvalidConfigException('Scenario not specified');
            }
        } else {
            $scenarioCommands = static::scenarioCommands();
            if ($action = $scenarioCommands[$this->scenario]) {
                if ($action === false) {
                    throw new NotSupportedException('The scenario can not be saved');
                }

                if (is_array($action) && $action[0] === null) {
                    $result = $action[1];
                } elseif (is_array($action)) {
                    $result = $action;
                } else {
                    $result = Inflector::id2camel($action);
                }
            } else {
                $result = Inflector::id2camel($this->scenario);
            }
        }

        return is_array($result) ? implode('', $result) : $result;
    }

    /**
     * Define an array of relations between scenario and API call action.
     *
     * Example:
     *
     * ```
     * [
     *      'update-name'                => 'set-name', /// ModuleSetName
     *      'update-related-name'        => [Action::formName(), 'SetName'], /// ActionSetName
     *      'update-self-case-sensetive' => [null, 'SomeSENSETIVE'] /// ModuleSomeSENSETIVE
     * ]
     * ~~
     *
     *  key string name of scenario
     *  value string|array
     *              string will be passed to [[Inflector::id2camel|id2camel]] inflator
     *              array - first attribute a module name, second - value
     *
     * Tricks: pass null as first argument of array to leave command's case unchanged (no inflator calling)
     *
     * @return array
     */
    public function scenarioCommands()
    {
        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);
    }
}