DBObject - Code Metrics - Inspection of ""Directory Structure" section moved to the separat..." - Asymptix/Framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 69d137...9b4748 )

by Dmytro

created 2016-08-31 05:27 UTC

DBObject C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	532
Duplicated Lines	3.76 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes	12
Bugs	5	Features	3

Metric	Value
c	12
b	5
f	3
dl	20
loc	532
rs	5.7097
wmc	67
lcom	1
cbo	6

29 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	1	1
A	getId()	0	7	2
A	setId()	0	3	1
A	getIdFieldName()	0	3	1
A	getTableName()	0	3	1
A	saveActivationFlag()	10	10	1
A	isActivated()	0	8	2
A	activate()	0	5	1
A	deactivate()	0	5	1
A	changeActivation()	0	7	2
A	saveRemovementFlag()	10	10	1
A	isRemoved()	0	8	2
A	remove()	0	5	1
A	restore()	0	5	1
A	changeRemovement()	0	7	2
A	isNewRecord()	0	7	2
A	save()	0	14	4
C	initQuery()	0	25	7
A	select()	0	3	1
A	_select()	0	6	1
A	_get()	0	5	1
A	update()	0	3	1
A	_update()	0	6	1
A	order()	0	5	1
A	limit()	0	9	2
F	go()	0	99	22
A	delete()	0	3	1
A	_delete()	0	17	2
A	getFieldName()	0	3	1

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

<?php

namespace Asymptix\db;

use Asymptix\core\Tools;

/**
 * DBObject class. Object oriented representation of DB record.
 *
 * @category Asymptix PHP Framework
 * @author Dmytro Zarezenko <[email protected]>
 * @copyright (c) 2009 - 2016, Dmytro Zarezenko
 *
 * @git https://github.com/Asymptix/Framework
 * @license http://opensource.org/licenses/MIT
 */
abstract class DBObject extends \Asymptix\core\Object {

    /**
     * Status constants.
     */
    const STATUS_ACTIVATED = 1;
    const STATUS_DEACTIVATED = 0;

    const STATUS_REMOVED = 1;
    const STATUS_RESTORED = 0;

    /**
     * DB Query object for Prepared Statement.
     *
     * @var DBPreparedQuery
     */
    private $dbQuery = null;

    /**
     * Creates new default object.
     */
    public function __construct() {}

    /**
     * Returns primary key value.
     *
     * @return mixed.

     */
    public function getId() {
        if (is_null(static::ID_FIELD_NAME)) {
            return null;
        }

        return $this->getFieldValue(static::ID_FIELD_NAME);
    }

    /**
     * Sets primary key value.
     *
     * @param mixed $recordId Key vaue.
     *
     * @return bool Success flag.
     * @throws DBCoreException If object has no field with such name.
     */
    public function setId($recordId) {
        return $this->setFieldValue(static::ID_FIELD_NAME, $recordId);
    }

    /**
     * Returns name of the primary key field.
     *
     * @return mixed
     */
    public static function getIdFieldName() {
        return static::ID_FIELD_NAME;
    }

    /**
     * Returns DBObject table name.
     *
     * @return string
     */
    public static function getTableName() {
        return static::TABLE_NAME;
    }

    /**
     * Saves activation flag to the database.
     *
     * @return int Returns the number of affected rows on success, and -1 if
     *            the last query failed.
     */
    public function saveActivationFlag() {

        return DBCore::doUpdateQuery(
            "UPDATE " . static::TABLE_NAME . "
                SET activation = ?
             WHERE " . static::ID_FIELD_NAME . " = ?
             LIMIT 1",
            "ii",
            [$this->activation, $this->id]
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        );
    }

    /**
     * Detects if current record is activated.
     *
     * @return bool
     *
     * @throws DBCoreException If record hos no 'activation' field.
     */
    public function isActivated() {
        $activation = $this->getFieldValue('activation');
        if (is_null($activation)) {
            throw new DBCoreException("This object has no parameter 'activation'");
        }

        return ($activation > 0);
    }

    /**
     * Activates record and save changes into the database.
     *
     * @return int
     */
    public function activate() {
        $this->setFieldValue('activation', self::STATUS_ACTIVATED);

        return $this->saveActivationFlag();
    }

    /**
     * Deactivates record and save changes into the database.
     *
     * @return int
     */
    public function deactivate() {
        $this->setFieldValue('activation', self::STATUS_DEACTIVATED);

        return $this->saveActivationFlag();
    }

    /**
     * Changes record activation flag and save changes into the database.
     */
    public function changeActivation() {
        if ($this->isActivated()) {
            $this->deactivate();
        } else {
            $this->activate();
        }
    }

    /**
     * Saves removement flag to the database.
     *
     * @return int Returns the number of affected rows on success, and -1 if
     *            the last query failed.
     */
    public function saveRemovementFlag() {

        return DBCore::doUpdateQuery(
            "UPDATE " . static::TABLE_NAME . "
                SET removed = ?
             WHERE " . static::ID_FIELD_NAME . " = ?
             LIMIT 1",
            "ii",
            [$this->removed, $this->id]
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        );
    }

    /**
     * Detects if current record is removed.
     *
     * @return bool
     *
     * @throws DBCoreException If record hos no 'removed' field.
     */
    public function isRemoved() {
        $isRemoved = $this->getFieldValue('removed');
        if (is_null($isRemoved)) {
            throw new DBCoreException("This object has no parameter 'removed'");
        }

        return ($isRemoved == self::STATUS_REMOVED);
    }

    /**
     * Enable removed flag of the record and save changes into the database.
     *
     * @return int
     */
    public function remove() {
        $this->setFieldValue('removed', self::STATUS_REMOVED);

        return $this->saveRemovementFlag();
    }

    /**
     * Disable removed flag of the record and save changes into the database.
     *
     * @return int
     */
    public function restore() {
        $this->setFieldValue('removed', self::STATUS_RESTORED);

        return $this->saveRemovementFlag();
    }

    /**
     * Changes record removement flag and save changes into the database.
     */
    public function changeRemovement() {
        if ($this->isRemoved()) {
            $this->restore();
        } else {
            $this->remove();
        }
    }

    /**
     * Detects if current DBObject represents not existed DB record.
     *
     * @return bool
     */
    public function isNewRecord() {
        if (is_null(static::ID_FIELD_NAME)) {
            return true;
        }

        return ($this->id == 0);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
    }

    /**
     * Saves DBObject to the database. If this is a new object - INSERT SQL
     *           instruction executes, if existed one - UPDATE.
     *
     * @param bool $debug Debug mode flag.
     *
     * @return mixed Primary key value.
     * @throws DBCoreException If some database error occurred.
     */
    public function save($debug = false) {
        if ($this->isNewRecord()) {
            $insertionId = DBCore::insertDBObject($this, $debug);
            if (Tools::isInteger($insertionId) && $insertionId > 0) {
                $this->setId($insertionId);

                return $insertionId;
            }
            throw new DBCoreException("Save database object error");
        }
        DBCore::updateDBObject($this, $debug);

        return $this->id;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
    }

    /**
     * Inits SQL query.
     *
     * @param string $queryType Type of the SQL query from types list from DBQuery.
     * @param array $conditions List of conditions for WHERE instruction.
     * @param array $fields List of fields for INSERT or UPDATE types of SQL queries.
     *
     * @return DBObject Itself.
     */
    public function initQuery($queryType, $conditions = [], $fields = []) {
        $this->dbQuery = new DBPreparedQuery();

        $this->dbQuery->setType($queryType);
        $this->dbQuery->conditions = $conditions;
        $this->dbQuery->fields = $fields;

        /*
         * Inits LIMIT if called dynamic select() or update() method.
         */
        if (is_null($this->dbQuery->limit)) {
            $backTrace = debug_backtrace();
            if (is_array($backTrace) && isset($backTrace[1])) {
                $prevCall = $backTrace[1];
                if (is_array($prevCall) && isset($prevCall['type'])) {
                    if ($prevCall['type'] == '->') { // dynamic method was called
                        $this->dbQuery->limit = 1;
                    }
                }
            }
            unset($backTrace);
        }

        return $this;
    }

    /**
     * Prepare DBObject for the SELECT SQL query.
     *
     * @param array $conditions List of the conditions fields
     *           (fieldName => fieldValue or sqlCondition => params).
     *
     * @return DBObject Current object.
     */
    public function select($conditions = []) {
        return $this->initQuery(DBQueryType::SELECT, $conditions);
    }

    /**
     * Static way to prepare DBObject for the SELECT SQL query.
     *
     * @param array $conditions List of the conditions fields
     *           (fieldName => fieldValue or sqlCondition => params).
     *
     * @return DBObject Current object.
     */
    public static function _select($conditions = []) {
        $ref = new \ReflectionClass(get_called_class());
        $dbObject = $ref->newInstance();

        return $dbObject->initQuery(DBQueryType::SELECT, $conditions);
    }

    /**
     * Select and returns DB record for current DBObject table by record ID.
     *
     * @param mixed $recordId Record ID.
     * @param bool $debug Debug mode flag.
     *
     * @return DBObject Record object or null.
     */
    public static function _get($recordId, $debug = false) {
        return static::_select([
            static::ID_FIELD_NAME => $recordId
        ])->limit(1)->go($debug);
    }

    /**
     * Prepare DBObject for the UPDATE SQL query.
     *
     * @param type $fields List of fields to be updated
     *           (fieldName => fieldValue or sqlAssignment => params).
     * @param array $conditions List of the conditions fields
     *           (fieldName => fieldValue or sqlCondition => params).
     *
     * @return DBObject Current object.
     */
    public function update($fields = [], $conditions = []) {
        return $this->initQuery(DBQueryType::UPDATE, $conditions, $fields);
    }

    /**
     * Static way to prepare DBObject for the UPDATE SQL query.
     *
     * @param type $fields List of fields to be updated
     *           (fieldName => fieldValue or sqlAssignment => params).
     * @param array $conditions List of the conditions fields
     *           (fieldName => fieldValue or sqlCondition => params).
     *
     * @return DBObject Current object.
     */
    public static function _update($fields = [], $conditions = []) {
        $ref = new \ReflectionClass(get_called_class());
        $dbObject = $ref->newInstance();

        return $dbObject->initQuery(DBQueryType::UPDATE, $conditions, $fields);
    }

    /**
     * Prepare DBObject for the select query (for ORDER expression).
     *
     * @param array $order List of order conditions (fieldName => order),
     *           order may be 'ASC' OR 'DESC'.
     *
     * @param array $order
     * @return DBObject Current object.
     */
    public function order($order = null) {
        $this->dbQuery->order = $order;
function aContainsB(array $needle = null, array  $haystack) {
    if (!$needle) {
        return false;
    }

    return array_intersect($haystack, $needle) == $haystack;
}

        return $this;
    }

    /**
     * Prepare DBObject for the select query (for LIMIT expression).
     *
     * @param int $offset Limit offset value (or count if this is single
     *           parameter).
     * @param int $count Number of records to select.
     *
     * @return DBObject Current object.
     */
    public function limit($offset = 1, $count = null) {
        if (is_null($count)) {
            $this->dbQuery->limit = $offset;
        } else {
            $this->dbQuery->limit = [$offset, $count];
        }

        return $this;
    }

    /**
     * Selects DB record(s) for current DBObject table according to params.
     *
     * @param bool $debug Debug mode flag.
     *
     * @return mixed DBObject, array of DBObject or null.
     * @throws DBCoreException If some DB or query syntax errors occurred.
     */
    public function go($debug = false) {
        switch ($this->dbQuery->getType()) {
            case (DBQueryType::SELECT):
                $this->dbQuery->query = "SELECT * FROM " . static::TABLE_NAME;
                break;
            case (DBQueryType::UPDATE):
                $this->dbQuery->query = "UPDATE " . static::TABLE_NAME . " SET ";
                $this->dbQuery->sqlPushValues($this->dbQuery->fields);
                break;
            case (DBQueryType::DELETE):
                $this->dbQuery->query = "DELETE FROM " . static::TABLE_NAME;
                break;
        }

        /*
         * Conditions
         */
        if ($this->isNewRecord()) {
            if (!empty($this->dbQuery->conditions)) {
                $this->dbQuery->query.= " WHERE ";
                $this->dbQuery->sqlPushValues($this->dbQuery->conditions, " AND ");
            }
        } else {
            $this->dbQuery->query.= " WHERE ";
            $this->dbQuery->sqlPushValues([static::ID_FIELD_NAME => $this->id]);
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        }

        /*
         * Order
         */
        if ($this->isNewRecord()) {
            if (!empty($this->dbQuery->order)) {
                $this->dbQuery->query.= " ORDER BY";
                if (is_array($this->dbQuery->order)) {
                    foreach ($this->dbQuery->order as $fieldName => $ord) {
                        $this->dbQuery->query.= " " . $fieldName . " " . $ord . ",";
                    }
                    $this->dbQuery->query = substr($this->dbQuery->query, 0, strlen($this->dbQuery->query) - 1);
                } elseif (is_string($this->dbQuery->order)) {
                    $this->dbQuery->query.= " " . $this->dbQuery->order;
                }
            }
        }

        /*
         * Limit
         */
        $count = null;
        if ($this->isNewRecord()) {
            if (!is_null($this->dbQuery->limit)) {
                if (Tools::isInteger($this->dbQuery->limit)) {
                    $this->dbQuery->query.= " LIMIT " . $this->dbQuery->limit;
                    $count = $this->dbQuery->limit;
                } elseif (is_array($this->dbQuery->limit) && count($this->dbQuery->limit) == 2) {
                    $offset = $this->dbQuery->limit[0];
                    $count = $this->dbQuery->limit[1];
                    if (Tools::isInteger($offset) && Tools::isInteger($count)) {
                        $this->dbQuery->query.= " LIMIT " . $offset . ", " . $count;
                    } else {
                        throw new DBCoreException("Invalid LIMIT param in select() method.");
                    }
                } else {
                    throw new DBCoreException("Invalid LIMIT param in select() method.");
                }
            }
        } else {
            $this->dbQuery->query.= " LIMIT 1";
            $count = 1;
        }

        if ($debug) {
            DBQuery::showQueryDebugInfo(
                $this->dbQuery->query,
                $this->dbQuery->types,
                $this->dbQuery->params
            );
        } else {
            if ($this->dbQuery->isSelector()) {
                $stmt = $this->dbQuery->go();
                if ($stmt !== false) {
                    $data = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
                    if ($count !== 1) {
                        $data = DBCore::selectDBObjectsFromStatement($stmt, $this);
                    } else {
                        $data = DBCore::selectDBObjectFromStatement($stmt, $this);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                    }
                    $stmt->close();

                    return $data;
                }

                return null;
            }

            return $this->dbQuery->go();
        }

        return null;
    }

    /**
     * Deletes DB record for current DBObject.
     *
     * @return mixed Number of affected rows (1 if some record was deleted,
     *            0 - if no) or FALSE if some error occurred.
     */
    public function delete() {
        return DBCore::deleteDBObject($this);
    }

    /**
     * Deletes DB record by ID or condition.
     *
     * @param mixed $conditions List of the conditions fields
     *           (fieldName => fieldValue or sqlCondition => params).
     *           or ID value of the record
     * @return DBObject Current object.
     */
    public static function _delete($conditions = []) {
        $ref = new \ReflectionClass(get_called_class());
        $dbObject = $ref->newInstance();

        if (!is_array($conditions)) { // Just record ID provided
            $recordId = $conditions;
            $conditions = [
                $dbObject->getIdFieldName() => $recordId
            ];
            $dbObject->initQuery(DBQueryType::DELETE, $conditions);
            $dbObject->dbQuery->limit = 1;

            return $dbObject;
        }

        return $dbObject->initQuery(DBQueryType::DELETE, $conditions);
    }

    /**
     * Returns DB table field name by it's camelcase variant.
     *
     * @param string $methodNameFragment
     *
     * @return string
     */
    protected function getFieldName($methodNameFragment) {
        return substr(strtolower(preg_replace("#([A-Z]{1})#", "_$1", $methodNameFragment)), 1);
    }

}


Asymptix / Framework