QueryBuilder - Code Metrics - Inspection of "Rework to use yiisoft/yii2-httpclient" - hiqdev/yii2-hiart - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#10)

by Edgard

created 2017-06-02 20:07 UTC

QueryBuilder B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	333
Duplicated Lines	7.21 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

Metric	Value
wmc	48
lcom	1
cbo	5
dl	24
loc	333
rs	8.4864
c	0
b	0
f	0

26 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	createRequest()	0	4	1
A	build()	0	20	2
A	buildAuth()	0	4	1
A	buildMethod()	0	17	2
A	buildFrom()	0	4	1
A	buildWhere()	0	10	2
A	buildCount()	0	11	2
A	buildOrderBy()	0	4	1
A	buildLimit()	0	4	1
A	insert()	0	12	1
A	update()	13	13	1
A	delete()	11	11	1
A	perform()	0	6	1
B	buildCondition()	0	37	5
A	buildHashCondition()	0	14	3
A	buildLikeCondition()	0	4	1
A	buildIlikeCondition()	0	4	1
A	buildCompareCondition()	0	8	2
A	buildAndCondition()	0	14	4
A	buildBetweenCondition()	0	4	1
D	buildInCondition()	0	30	9
A	buildNotInCondition()	0	4	1
A	buildEqCondition()	0	6	1
A	buildNotEqCondition()	0	6	1
A	buildCompositeInCondition()	0	4	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 QueryBuilder 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 QueryBuilder, and based on these observations, apply Extract Interface, too.

<?php
/**
 * ActiveRecord for API.
 *
 * @see      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\InvalidParamException;
use yii\base\NotSupportedException;
use yii\base\Object;
use yii\helpers\ArrayHelper;
use yii\httpclient\Request;

/**
 * Abstract QueryBuilder.
 *
 * QueryBuilder builds a request from the specification given as a [[Query]] object.
 */
class QueryBuilder extends Object
{
    /**
     * @var Connection
     */
    public $db;

    public function __construct($connection, $config = [])
    {
        $this->db = $connection;
        parent::__construct($config);
    }

    /**
     * @param array $params
     * @return Request
     */
    public function createRequest($params = [])

    {
        return $this->db->createRequest();
    }

    /**
     * Builds config array to create Command.
     * @param Query $query
     * @throws NotSupportedException
     * @return Request
     */
    public function build(Query $query, $params = [], array $options = [])
    {
        $query = $query->prepare($this);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $params = empty($params) ? $query->params : array_merge($params, $query->params);

        $request = $this->createRequest($params);

        $this->buildAuth($request, $params);
class User
{
    private $email;

    public function getEmail()
    {
        return $this->email;
    }

    public function setEmail($email)
    {
        $this->email = $email;
    }
}
        $this->buildMethod($request, 'select', $params);
        $this->buildFrom($request, $query->from, $params);
        $this->buildWhere($request, $query->where, $params);

        $this->buildCount($request, $query->count, $params);
        $this->buildOrderBy($request, $query->orderBy, $params);
class User
{
    private $email;

    public function getEmail()
    {
        return $this->email;
    }

    public function setEmail($email)
    {
        $this->email = $email;
    }
}
        $this->buildLimit($request, $query->limit, $query->offset, $params);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

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

        $request->setOptions($options);

        return $request;
    }

    public function buildAuth(Request $request, $params = [])

    {
        return $request;
    }

    public function buildMethod(Request $request, $action, $params = [])

    {
        static $defaultMethods = [
            'delete' => 'DELETE',
            'get'    => 'GET',
            'head'   => 'HEAD',
            'insert' => 'POST',
            'post'   => 'GET',
            'put'    => 'PUT',
            'search' => 'GET',
            'select' => 'GET',
            'update' => 'PUT',
        ];

        $method = isset($defaultMethods[$action]) ? $defaultMethods[$action] : 'POST';
        return $request->setMethod($method);
    }

    public function buildFrom(Request $request, $from, $params = [])

    {
        return $request->setUrl($from);
    }

    public function buildWhere(Request $request, $condition, $params = [])
    {
        $where = $this->buildCondition($condition, $params);


        if ($where) {
            $request->addData($where);
        }

        return $request;
    }

    public function buildCount(Request $request, $count, $params = [])

    {
        if ($count) {
            $request->on(Request::EVENT_AFTER_SEND, function (\yii\httpclient\RequestEvent $event) {
                $data = $event->response->getData();
                $event->response->setData(count($data));
            });
        }

        return $request;
    }

    public function buildOrderBy(Request $request, $orderBy, $params = [])

    {
        return $request;
    }

    public function buildLimit(Request $request, $limit, $offset = 0, $params = [])

    {
        return $request;
    }

    /**
     * Creates insert request.
     * @param string $url
     * @param array $columns
     * @param array $options
     * @return AbstractTransport
     */
    public function insert($url, $columns, &$params = [], array $options = [])

    {
        $request = $this->createRequest();

        $this->buildMethod($request, 'insert', $params);
        $this->buildFrom($request, url, $params);

        $request->setData($columns);
        $request->setOptions($options);

        return $request;
    }

    /**
     * Creates update request.
     * @param string $url
     * @param array $columns
     * @param array $condition
     * @param array $options
     * @return AbstractTransport
     */
    public function update($url, $columns, $condition = [], &$params = [], array $options = [])

    {
        $request = $this->createRequest();
        $this->buildMethod($request, 'update', $params);
        $this->buildFrom($request, url, $params);

        $this->buildWhere($request, $condition, $params);

        $request->addData($columns);
        $request->setOptions($options);

        return $request;
    }

    /**
     * Creates delete request.
     * @param string $table
     * @param array $condition
     * @param array $options
     * @return AbstractTransport
     */
    public function delete($table, $condition = [], &$params = [], array $options = [])

    {
        $request = $this->createRequest();
        $this->buildMethod($request, 'update', $params);
        $this->buildFrom($request, url, $params);
        $this->buildWhere($request, $condition, $params);

        $request->setOptions($options);

        return $request;
    }

    /**
     * Creates request for given action.
     * @param string $action
     * @param string $table
     * @param mixed $body
     * @param array $options
     * @return AbstractTransport
     */
    public function perform($action, $table, $body, $options = [])
    {
        $query = $this->createQuery($action, $table, $options)->body($body);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }

        return $this->createRequest($query);
    }

    public function buildCondition($condition)
    {
        static $builders = [
            'and'     => 'buildAndCondition',
            'between' => 'buildBetweenCondition',
            'eq'      => 'buildEqCondition',
            'ne'      => 'buildNotEqCondition',
            'in'      => 'buildInCondition',
            'ni'      => 'buildNotInCondition',
            'like'    => 'buildLikeCondition',
            'ilike'   => 'buildIlikeCondition',
            'gt'      => 'buildCompareCondition',
            'ge'      => 'buildCompareCondition',
            'lt'      => 'buildCompareCondition',
            'le'      => 'buildCompareCondition',
        ];
        if (empty($condition)) {
            return [];
        }
        if (!is_array($condition)) {
            throw new NotSupportedException('String conditions in where() are not supported by HiArt.');
        }

        if (isset($condition[0])) { // operator format: operator, operand 1, operand 2, ...
            $operator = strtolower($condition[0]);
            if (isset($builders[$operator])) {
                $method = $builders[$operator];
                array_shift($condition); // Shift build condition

                return $this->$method($operator, $condition);
            } else {
                throw new InvalidParamException('Found unknown operator in query: ' . $operator);
            }
        } else {
            return $this->buildHashCondition($condition);
        }
    }

    protected function buildHashCondition($condition)
    {
        $parts = [];
        foreach ($condition as $attribute => $value) {
            if (is_array($value)) { // IN condition
                // $parts[] = [$attribute.'s' => join(',',$value)];

                $parts[$attribute . 's'] = implode(',', $value);
            } else {
                $parts[$attribute] = $value;
            }
        }

        return $parts;
    }

    protected function buildLikeCondition($operator, $operands)

    {
        return [$operands[0] . '_like' => $operands[1]];
    }

    protected function buildIlikeCondition($operator, $operands)

    {
        return [$operands[0] . '_ilike' => $operands[1]];
    }

    protected function buildCompareCondition($operator, $operands)
    {
        if (!isset($operands[0], $operands[1])) {
            throw new InvalidParamException("Operator '$operator' requires three operands.");
        }

        return [$operands[0] . '_' . $operator => $operands[1]];
    }

    protected function buildAndCondition($operator, $operands)

    {
        $parts = [];
        foreach ($operands as $operand) {
            if (is_array($operand)) {
                $parts = ArrayHelper::merge($this->buildCondition($operand), $parts);
            }
        }
        if (!empty($parts)) {
            return $parts;
        } else {
            return [];
        }
    }

    protected function buildBetweenCondition($operator, $operands)

    {
        throw new NotSupportedException('Between condition is not supported by HiArt.');
    }

    protected function buildInCondition($operator, $operands, $not = false)
    {
        if (!isset($operands[0], $operands[1])) {
            throw new InvalidParamException("Operator '$operator' requires two operands.");
        }

        list($column, $values) = $operands;

        if (count($column) > 1) {
            return $this->buildCompositeInCondition($operator, $column, $values);
        } elseif (is_array($column)) {
            $column = reset($column);
        }

        foreach ((array) $values as $i => $value) {
            if (is_array($value)) {
                $values[$i] = $value = isset($value[$column]) ? $value[$column] : null;
            }
            if ($value === null) {
                unset($values[$i]);
            }
        }

        if ($not) {
            $key = $column . '_ni'; // not in
        } else {
            $key = $column . '_in';
        }
        return [$key => $values];
    }

    protected function buildNotInCondition($operator, $operands)
    {
        return $this->buildInCondition($operator, $operands, true);
    }

    protected function buildEqCondition($operator, $operands)

    {
        $key = array_shift($operands);

        return [$key => reset($operands)];
    }

    protected function buildNotEqCondition($operator, $operands)
    {
        $key = array_shift($operands);

        return [$key . '_' . $operator => reset($operands)];
    }

    protected function buildCompositeInCondition($operator, $columns, $values)

    {
        throw new NotSupportedException('composite in is not supported by HiArt.');
    }
}


1			<?php
2			/**
3			* ActiveRecord for API.
4			*
5			* @see 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\InvalidParamException;
14			use yii\base\NotSupportedException;
15			use yii\base\Object;
16			use yii\helpers\ArrayHelper;
17			use yii\httpclient\Request;
18
19			/**
20			* Abstract QueryBuilder.
21			*
22			* QueryBuilder builds a request from the specification given as a [[Query]] object.
23			*/
24			class QueryBuilder extends Object
25			{
26			/**
27			* @var Connection
28			*/
29			public $db;
30
31			public function __construct($connection, $config = [])
32			{
33			$this->db = $connection;
34			parent::__construct($config);
35			}
36
37			/**
38			* @param array $params
39			* @return Request
40			*/

hiqdev / yii2-hiart