DbRepository - Code Metrics - Inspection of "Refactored query result processing" - lrc-se/bth-anax-repository - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( f910eb...6d2d97 )

by LRC

created 2017-10-23 14:41 UTC

DbRepository C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	426
Duplicated Lines	7.51 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

100%

Importance

Changes

Metric	Value
wmc	55
lcom	1
cbo	5
dl	32
loc	426
ccs	170
cts	170
cp	1
rs	6.8
c	0
b	0
f	0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	getCollectionName()	0	4	1
A	getModelClass()	0	4	1
A	find()	0	4	2
A	getFirst()	0	4	1
A	getAll()	0	4	1
A	save()	0	8	2
A	delete()	0	8	1
A	count()	0	6	2
C	executeQuery()	0	25	8
C	populateModelFromJoin()	0	35	8
B	processSingleResult()	14	14	5
B	processMultipleResults()	18	18	5
C	setupJoin()	0	56	10
A	prefixModelAttributes()	0	7	2
A	create()	0	9	1
A	update()	0	11	1
A	getMutableAttributes()	0	14	3

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

<?php

namespace LRC\Repository;

/**
 * Base class for database-backed repositories for data access.
 *
 * @SuppressWarnings(PHPMD.ExcessiveClassComplexity)
 */
class DbRepository extends ManagedRepository implements RepositoryInterface
{
    /**
     * @var \Anax\Database\DatabaseQueryBuilder     Database service.
     */
    protected $db;
    
    /**
     * @var string  Database table name.
     */
    protected $table;
    
    /**
     * @var string  Model class name.
     */
    protected $modelClass;
    
    /**
     * @var string  Primary key column.
     */
    protected $key;
    
    
    /**
     * Constructor.
     *
     * @param \Anax\Database\DatabaseQueryBuilder   $db         Database service.
     * @param string                                $table      Database table name.
     * @param string                                $modelClass Model class name.
     * @param string                                $key        Primary key column.
     */
    public function __construct($db, $table, $modelClass, $key = 'id')
    {
        $this->db = $db;
        $this->table = $table;
        $this->modelClass = $modelClass;
        $this->key = $key;
    }
    
    
    /**
     * Return the name of the database table represented by the repository.
     */
    public function getCollectionName()
    {
        return $this->table;
    }
    
    
    /**
     * Return the class of the model handled by the repository.
     */
    public function getModelClass()
    {
        return $this->modelClass;
    }
    
    
    /**
     * Find and return first entry by key.
     *
     * @param string|null   $column Key column name (pass null to use registered primary key).
     * @param mixed         $value  Key value.
     *
     * @return mixed                Model instance.
     */
    public function find($column, $value)
    {
        return $this->getFirst((is_null($column) ? $this->key : $column) . ' = ?', [$value]);
    }
    
    
    /**
     * Retrieve first entry, optionally filtered by search criteria.
     * 
     * @param string $conditions    Where conditions.
     * @param array  $values        Array of condition values to bind.
     * @param array  $options       Query options.
     * 
     * @return mixed                Model instance.
     */
    public function getFirst($conditions = null, $values = [], $options = [])
    {
        return $this->processSingleResult($this->executeQuery(null, $conditions, $values, $options));
    }
    
    
    /**
     * Retrieve all entries, optionally filtered by search criteria.
     * 
     * @param string $conditions    Where conditions.
     * @param array  $values        Array of condition values to bind.
     * @param array  $options       Query options.
     * 
     * @return array                Array of all matching entries.
     */
    public function getAll($conditions = null, $values = [], $options = [])
    {
        return $this->processMultipleResults($this->executeQuery(null, $conditions, $values, $options));
    }
    
    
    /**
     * Save entry by inserting if ID is missing and updating if ID exists.
     * 
     * @param mixed $model  Model instance.
     *
     * @return void
     */
    public function save($model)
    {
        if (isset($model->{$this->key})) {
            return $this->update($model);
        }
        
        return $this->create($model);
    }
    
    
    /**
     * Delete entry.
     *
     * @param mixed $model  Model instance.
     */
    public function delete($model)
    {
        $this->db->connect()
            ->deleteFrom($this->table)
            ->where($this->key . ' = ?')
            ->execute([$model->{$this->key}]);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $model->{$this->key} = null;
    }
    
    
    /**
     * Count entries, optionally filtered by search criteria.
     *
     * @param string $conditions    Where conditions.
     * @param array  $values        Array of condition values to bind.
     * 
     * @return int                  Number of entries.
     */
    public function count($conditions = null, $values = [])
    {
        $res = $this->executeQuery('COUNT(' . $this->key . ') AS num', $conditions, $values)
            ->fetch();
        return (isset($res->num) ? (int)$res->num : 0);
    }
    
    
    /**
     * Execute query for selection methods.
     * 
     * @param   string  $select                     Selection criteria.
     * @param   string  $conditions                 Where conditions.
     * @param   array   $values                     Array of where condition values to bind.
     * @param   array   $options                    Query options.
     * 
     * @return \Anax\Database\DatabaseQueryBuilder  Database service instance with executed internal query.
     */
    protected function executeQuery($select = null, $conditions = null, $values = [], $options = [])
    {
        $query = $this->db->connect();
        if (!empty($this->fetchRefs)) {
            $query = $this->setupJoin($query, $select, $conditions, (isset($options['order']) ? $options['order'] : null));
        } else {
            $query = (!is_null($select) ? $query->select($select) : $query->select());
            $query = $query->from($this->table);
            if (!is_null($conditions)) {
                $query = $query->where($conditions);
            }
            if (isset($options['order'])) {
                $query = $query->orderBy($options['order']);
            }
        }
        
        if (isset($options['limit'])) {
            $query = $query->limit($options['limit']);
        }
        if (isset($options['offset'])) {
            $query = $query->offset($options['offset']);
        }
        
        return $query->execute($values);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }
    
    
    
    /**
     * Populate model instance including retrieved references from join query result.
     * 
     * @param object $result    Query result.
     * 
     * @return mixed            Populated model instance.
     */
    protected function populateModelFromJoin($result)
    {
        // extract main model
        $model = new $this->modelClass();
        foreach (array_keys(get_object_vars($model)) as $attr) {
            $model->$attr = $result->$attr;
        }
        
        // extract referenced models
        $refs = $model->getReferences();
        $refs2 = (is_array($this->fetchRefs) ? $this->fetchRefs : array_keys($refs));
        sort($refs2);
        foreach ($refs2 as $idx => $name) {
            $prefix = "REF{$idx}_{$name}__";
            
            // handle null result
            if (is_null($result->{$prefix . $refs[$name]['key']})) {
                $refModel = null;
            } else {
                $refModel = new $refs[$name]['model']();
                foreach (array_keys(get_object_vars($refModel)) as $attr) {
                    $refModel->$attr = $result->{$prefix . $attr};
                }
            }
            
            // inject manager reference
            if ($refModel && $this->manager) {
                $this->manager->manageModel($refModel);
            }
            
            $model->$name = $refModel;
        }
        
        return $model;
    }
    
    
    /**
     * Process single query result and return model instance.
     *
     * @param \Anax\Database\DatabaseQueryBuilder   $query  Database service instance with executed internal query.
     *
     * @return mixed                                        Model instance.
     */
    protected function processSingleResult($query)

    {
        if (!empty($this->fetchRefs)) {
            $res = $query->fetch();
            $model = ($res ? $this->populateModelFromJoin($res) : $res);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        } else {
            $model = $query->fetchClass($this->modelClass);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }
        if ($model && isset($this->manager)) {
            $this->manager->manageModel($model);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        }
        $this->fetchReferences(false);
        return $model;
    }
    
    
    /**
     * Process multiple query results and return model instances.
     *
     * @param \Anax\Database\DatabaseQueryBuilder   $query  Database service instance with executed internal query.
     *
     * @return array                                        Array of model instances.
     */
    protected function processMultipleResults($query)

    {
        if (!empty($this->fetchRefs)) {
            $models = [];
            foreach ($query->fetchAll() as $model) {
                $models[] = $this->populateModelFromJoin($model);
            }
        } else {
            $models = $query->fetchAllClass($this->modelClass);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }
        if (isset($this->manager)) {
            foreach ($models as $model) {
                $this->manager->manageModel($model);
            }
        }
        $this->fetchReferences(false);
        return $models;
    }
    
    
    /**
     * Set up join query for reference retrieval.
     *
     * @param \Anax\Database\DatabaseQueryBuilder   $query      Database service instance with initialized query.
     * @param string                                $select     Selection criteria.
     * @param string                                $conditions Where conditions.
     * @param string                                $order      Order by clause.
     *
     * @return \Anax\Database\DatabaseQueryBuilder              Database service instance with prepared join query.
     *
     * @SuppressWarnings(PHPMD.CyclomaticComplexity)
     * @SuppressWarnings(PHPMD.NPathComplexity)
     */
    private function setupJoin($query, $select, $conditions, $order = null)
    {
        // find references
        $model = new $this->modelClass();
        $refs = $model->getReferences();
        if (is_array($this->fetchRefs)) {
            $refs = array_intersect_key($refs, array_flip($this->fetchRefs));
        }
        ksort($refs);
        
        // prefix main model selection
        if (!is_null($select)) {
            $select = $this->prefixModelAttributes($select, $model);
        } else {
            $select = $this->table . '.*';
        }
        
        // set up reference aliases and join conditions
        $select = [$select];
        $join = [];
        $idx = 0;
        foreach ($refs as $name => $ref) {
            // prefix attributes
            $refTable = "REF{$idx}_{$name}";
            $idx++;
            foreach (array_keys(get_object_vars(new $ref['model']())) as $attr) {
                $select[] = "{$refTable}.{$attr} AS '{$refTable}__{$attr}'";
            }
            
            // generate join conditions
            $joinCond = $this->table . '.' . $ref['attribute'] . " = {$refTable}." . $ref['key'];
            $refRepo = $this->manager->getByClass($ref['model']);
            if ($this->softRefs && $refRepo instanceof SoftDbRepository) {
                $joinCond .= " AND $refTable." . $refRepo->getDeletedAttribute() . ' IS NULL';
            }
            $join[] = [$refRepo->getCollectionName() . " AS $refTable", $joinCond];
        }
        
        // generate join query
        $query = $query->select(implode(', ', $select))->from($this->table);
        foreach ($join as $args) {
            $query = $query->leftJoin($args[0], $args[1]);
        }
        
        // prefix where conditions
        if (!is_null($conditions)) {
            $query = $query->where($this->prefixModelAttributes($conditions, $model));
        }
        
        // prefix order by clause
        if (!is_null($order)) {
            $query = $query->orderBy($this->prefixModelAttributes($order, $model));
        }
        
        return $query;
    }
    
    
    /**
     * Prefix model attributes with the associated table name.
     * 
     * @param string $input     Input string.
     * @param object $model     Model instance.
     * 
     * @return string           String with table-prefixed attributes.
     */
    private function prefixModelAttributes($input, $model)
    {
        foreach (array_keys(get_object_vars($model)) as $attr) {
            $input = preg_replace('/\\b' . $attr . '\\b/', $this->table . ".$attr", $input);
        }
        return $input;
    }
    
        
    /**
     * Create new entry.
     * 
     * @param mixed $model  Model instance.
     */
    private function create($model)
    {
        $attrs = $this->getMutableAttributes($model);
        $this->db
            ->connect()
            ->insert($this->table, array_keys($attrs))
            ->execute(array_values($attrs));
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $model->{$this->key} = $this->db->lastInsertId();
    }
    
    
    /**
     * Update entry.
     * 
     * @param mixed $model  Model instance.
     */
    private function update($model)
    {
        $attrs = $this->getMutableAttributes($model);
        $values = array_values($attrs);
        $values[] = $model->{$this->key};
        $this->db
            ->connect()
            ->update($this->table, array_keys($attrs))
            ->where($this->key . ' = ?')
            ->execute($values);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }
    
    
    /**
     * Get mutable model attributes.
     *
     * @param object $model Model instance.
     *
     * @return array        Array of attributes.
     */
    private function getMutableAttributes($model)
    {
        $attrs = get_object_vars($model);
        unset($attrs[$this->key]);
        
        // remove reference attributes, if any
        if ($model instanceof ManagedModelInterface) {
            foreach (array_keys($model->getReferences()) as $ref) {
                unset($attrs[$ref]);
            }
        }
        
        return $attrs;
    }
}


1			<?php
2
3			namespace LRC\Repository;
4
5			/**
6			* Base class for database-backed repositories for data access.
7			*
8			* @SuppressWarnings(PHPMD.ExcessiveClassComplexity)
9			*/
10			class DbRepository extends ManagedRepository implements RepositoryInterface
11			{
12			/**
13			* @var \Anax\Database\DatabaseQueryBuilder Database service.
14			*/
15			protected $db;
16
17			/**
18			* @var string Database table name.
19			*/
20			protected $table;
21
22			/**
23			* @var string Model class name.
24			*/
25			protected $modelClass;
26
27			/**
28			* @var string Primary key column.
29			*/
30			protected $key;
31
32
33			/**
34			* Constructor.
35			*
36			* @param \Anax\Database\DatabaseQueryBuilder $db Database service.
37			* @param string $table Database table name.
38			* @param string $modelClass Model class name.
39			* @param string $key Primary key column.
40			*/
41	30		public function __construct($db, $table, $modelClass, $key = 'id')
42			{
43	30		$this->db = $db;
44	30		$this->table = $table;
45	30		$this->modelClass = $modelClass;
46	30		$this->key = $key;
47	30		}
48
49
50			/**
51			* Return the name of the database table represented by the repository.
52			*/
53	7		public function getCollectionName()
54			{
55	7		return $this->table;
56			}
57
58
59			/**
60			* Return the class of the model handled by the repository.
61			*/
62	14		public function getModelClass()
63			{
64	14		return $this->modelClass;
65			}
66
67
68			/**
69			* Find and return first entry by key.
70			*
71			* @param string\|null $column Key column name (pass null to use registered primary key).
72			* @param mixed $value Key value.
73			*
74			* @return mixed Model instance.
75			*/
76	18		public function find($column, $value)
77			{
78	18		return $this->getFirst((is_null($column) ? $this->key : $column) . ' = ?', [$value]);
79			}
80
81
82			/**
83			* Retrieve first entry, optionally filtered by search criteria.
84			*
85			* @param string $conditions Where conditions.
86			* @param array $values Array of condition values to bind.
87			* @param array $options Query options.
88			*
89			* @return mixed Model instance.
90			*/
91	19		public function getFirst($conditions = null, $values = [], $options = [])
92			{
93	19		return $this->processSingleResult($this->executeQuery(null, $conditions, $values, $options));
94			}
95
96
97			/**
98			* Retrieve all entries, optionally filtered by search criteria.
99			*
100			* @param string $conditions Where conditions.
101			* @param array $values Array of condition values to bind.
102			* @param array $options Query options.
103			*
104			* @return array Array of all matching entries.
105			*/
106	4		public function getAll($conditions = null, $values = [], $options = [])
107			{
108	4		return $this->processMultipleResults($this->executeQuery(null, $conditions, $values, $options));
109			}
110
111
112			/**
113			* Save entry by inserting if ID is missing and updating if ID exists.
114			*
115			* @param mixed $model Model instance.
116			*
117			* @return void
118			*/
119	5		public function save($model)
120			{
121	5		if (isset($model->{$this->key})) {
122	5		return $this->update($model);
123			}
124
125	3		return $this->create($model);
126			}
127
128
129			/**
130			* Delete entry.
131			*
132			* @param mixed $model Model instance.
133			*/
134	1		public function delete($model)
135			{
136	1		$this->db->connect()
137	1		->deleteFrom($this->table)
138	1		->where($this->key . ' = ?')
139	1		->execute([$model->{$this->key}]);
			0 ignored issues – show Documentation introduced 2017-10-04 15:29 UTC by Report Bug Copy Issue Report `array($model->{$this->key})` is of type `array<integer,?,{"0":"?"}>`, but the function expects a `string\|null`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
140	1		$model->{$this->key} = null;
141	1		}
142
143
144			/**
145			* Count entries, optionally filtered by search criteria.
146			*
147			* @param string $conditions Where conditions.
148			* @param array $values Array of condition values to bind.
149			*
150			* @return int Number of entries.
151			*/
152	4		public function count($conditions = null, $values = [])
153			{
154	4		$res = $this->executeQuery('COUNT(' . $this->key . ') AS num', $conditions, $values)
155	4		->fetch();
156	4		return (isset($res->num) ? (int)$res->num : 0);
157			}
158
159
160			/**
161			* Execute query for selection methods.
162			*
163			* @param string $select Selection criteria.
164			* @param string $conditions Where conditions.
165			* @param array $values Array of where condition values to bind.
166			* @param array $options Query options.
167			*
168			* @return \Anax\Database\DatabaseQueryBuilder Database service instance with executed internal query.
169			*/
170	26		protected function executeQuery($select = null, $conditions = null, $values = [], $options = [])
171			{
172	26		$query = $this->db->connect();
173	26		if (!empty($this->fetchRefs)) {
174	6		$query = $this->setupJoin($query, $select, $conditions, (isset($options['order']) ? $options['order'] : null));
175	6		} else {
176	26		$query = (!is_null($select) ? $query->select($select) : $query->select());
177	26		$query = $query->from($this->table);
178	26		if (!is_null($conditions)) {
179	26		$query = $query->where($conditions);
180	26		}
181	26		if (isset($options['order'])) {
182	4		$query = $query->orderBy($options['order']);
183	4		}
184			}
185
186	26		if (isset($options['limit'])) {
187	2		$query = $query->limit($options['limit']);
188	2		}
189	26		if (isset($options['offset'])) {
190	2		$query = $query->offset($options['offset']);
191	2		}
192
193	26		return $query->execute($values);
			0 ignored issues – show Documentation introduced 2017-10-04 15:29 UTC by Report Bug Copy Issue Report `$values` is of type `array`, but the function expects a `string\|null`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
194			}
195
196
197
198			/**
199			* Populate model instance including retrieved references from join query result.
200			*
201			* @param object $result Query result.
202			*
203			* @return mixed Populated model instance.
204			*/
205	6		protected function populateModelFromJoin($result)
206			{
207			// extract main model
208	6		$model = new $this->modelClass();
209	6		foreach (array_keys(get_object_vars($model)) as $attr) {
210	6		$model->$attr = $result->$attr;
211	6		}
212
213			// extract referenced models
214	6		$refs = $model->getReferences();
215	6		$refs2 = (is_array($this->fetchRefs) ? $this->fetchRefs : array_keys($refs));
216	6		sort($refs2);
217	6		foreach ($refs2 as $idx => $name) {
218	6		$prefix = "REF{$idx}_{$name}__";
219
220			// handle null result
221	6		if (is_null($result->{$prefix . $refs[$name]['key']})) {
222	3		$refModel = null;
223	3		} else {
224	6		$refModel = new $refs[$name]['model']();
225	6		foreach (array_keys(get_object_vars($refModel)) as $attr) {
226	6		$refModel->$attr = $result->{$prefix . $attr};
227	6		}
228			}
229
230			// inject manager reference
231	6		if ($refModel && $this->manager) {
232	6		$this->manager->manageModel($refModel);
233	6		}
234
235	6		$model->$name = $refModel;
236	6		}
237
238	6		return $model;
239			}
240
241
242			/**
243			* Process single query result and return model instance.
244			*
245			* @param \Anax\Database\DatabaseQueryBuilder $query Database service instance with executed internal query.
246			*
247			* @return mixed Model instance.
248			*/
249	22	View Code Duplication	protected function processSingleResult($query)
			0 ignored issues – show Duplication introduced 2017-10-23 14:43 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
250			{
251	22		if (!empty($this->fetchRefs)) {
252	4		$res = $query->fetch();
253	4		$model = ($res ? $this->populateModelFromJoin($res) : $res);
			0 ignored issues – show Documentation introduced 2017-10-22 08:11 UTC by Report Bug Copy Issue Report `$res` is of type `array`, but the function expects a `object`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
254	4		} else {
255	22		$model = $query->fetchClass($this->modelClass);
			0 ignored issues – show Documentation introduced 2017-10-22 08:11 UTC by Report Bug Copy Issue Report `$this->modelClass` is of type `string`, but the function expects a `object`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
256			}
257	22		if ($model && isset($this->manager)) {
258	10		$this->manager->manageModel($model);
			0 ignored issues – show Bug introduced 2017-10-22 08:11 UTC by Report Bug Copy Issue Report It seems like `$model` can also be of type `array`; however, `LRC\Repository\RepositoryManager::manageModel()` does only seem to accept `object`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
259	10		}
260	22		$this->fetchReferences(false);
261	22		return $model;
262			}
263
264
265			/**
266			* Process multiple query results and return model instances.
267			*
268			* @param \Anax\Database\DatabaseQueryBuilder $query Database service instance with executed internal query.
269			*
270			* @return array Array of model instances.
271			*/
272	6	View Code Duplication	protected function processMultipleResults($query)
			0 ignored issues – show Duplication introduced 2017-10-23 14:43 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
273			{
274	6		if (!empty($this->fetchRefs)) {
275	3		$models = [];
276	3		foreach ($query->fetchAll() as $model) {
277	3		$models[] = $this->populateModelFromJoin($model);
278	3		}
279	3		} else {
280	3		$models = $query->fetchAllClass($this->modelClass);
			0 ignored issues – show Documentation introduced 2017-10-22 08:11 UTC by Report Bug Copy Issue Report `$this->modelClass` is of type `string`, but the function expects a `object`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
281			}
282	6		if (isset($this->manager)) {
283	4		foreach ($models as $model) {
284	4		$this->manager->manageModel($model);
285	4		}
286	4		}
287	6		$this->fetchReferences(false);
288	6		return $models;
289			}
290
291
292			/**
293			* Set up join query for reference retrieval.
294			*
295			* @param \Anax\Database\DatabaseQueryBuilder $query Database service instance with initialized query.
296			* @param string $select Selection criteria.
297			* @param string $conditions Where conditions.
298			* @param string $order Order by clause.
299			*
300			* @return \Anax\Database\DatabaseQueryBuilder Database service instance with prepared join query.
301			*
302			* @SuppressWarnings(PHPMD.CyclomaticComplexity)
303			* @SuppressWarnings(PHPMD.NPathComplexity)
304			*/
305	6		private function setupJoin($query, $select, $conditions, $order = null)
306			{
307			// find references
308	6		$model = new $this->modelClass();
309	6		$refs = $model->getReferences();
310	6		if (is_array($this->fetchRefs)) {
311	5		$refs = array_intersect_key($refs, array_flip($this->fetchRefs));
312	5		}
313	6		ksort($refs);
314
315			// prefix main model selection
316	6		if (!is_null($select)) {
317	1		$select = $this->prefixModelAttributes($select, $model);
318	1		} else {
319	6		$select = $this->table . '.*';
320			}
321
322			// set up reference aliases and join conditions
323	6		$select = [$select];
324	6		$join = [];
325	6		$idx = 0;
326	6		foreach ($refs as $name => $ref) {
327			// prefix attributes
328	6		$refTable = "REF{$idx}_{$name}";
329	6		$idx++;
330	6		foreach (array_keys(get_object_vars(new $ref['model']())) as $attr) {
331	6		$select[] = "{$refTable}.{$attr} AS '{$refTable}__{$attr}'";
332	6		}
333
334			// generate join conditions
335	6		$joinCond = $this->table . '.' . $ref['attribute'] . " = {$refTable}." . $ref['key'];
336	6		$refRepo = $this->manager->getByClass($ref['model']);
337	6		if ($this->softRefs && $refRepo instanceof SoftDbRepository) {
338	3		$joinCond .= " AND $refTable." . $refRepo->getDeletedAttribute() . ' IS NULL';
339	3		}
340	6		$join[] = [$refRepo->getCollectionName() . " AS $refTable", $joinCond];
341	6		}
342
343			// generate join query
344	6		$query = $query->select(implode(', ', $select))->from($this->table);
345	6		foreach ($join as $args) {
346	6		$query = $query->leftJoin($args[0], $args[1]);
347	6		}
348
349			// prefix where conditions
350	6		if (!is_null($conditions)) {
351	5		$query = $query->where($this->prefixModelAttributes($conditions, $model));
352	5		}
353
354			// prefix order by clause
355	6		if (!is_null($order)) {
356	5		$query = $query->orderBy($this->prefixModelAttributes($order, $model));
357	5		}
358
359	6		return $query;
360			}
361
362
363			/**
364			* Prefix model attributes with the associated table name.
365			*
366			* @param string $input Input string.
367			* @param object $model Model instance.
368			*
369			* @return string String with table-prefixed attributes.
370			*/
371	6		private function prefixModelAttributes($input, $model)
372			{
373	6		foreach (array_keys(get_object_vars($model)) as $attr) {
374	6		$input = preg_replace('/\\b' . $attr . '\\b/', $this->table . ".$attr", $input);
375	6		}
376	6		return $input;
377			}
378
379
380			/**
381			* Create new entry.
382			*
383			* @param mixed $model Model instance.
384			*/
385	3		private function create($model)
386			{
387	3		$attrs = $this->getMutableAttributes($model);
388	3		$this->db
389	3		->connect()
390	3		->insert($this->table, array_keys($attrs))
391	3		->execute(array_values($attrs));
			0 ignored issues – show Documentation introduced 2017-10-22 08:11 UTC by Report Bug Copy Issue Report `array_values($attrs)` is of type `array<integer,?>`, but the function expects a `string\|null`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
392	3		$model->{$this->key} = $this->db->lastInsertId();
393	3		}
394
395
396			/**
397			* Update entry.
398			*
399			* @param mixed $model Model instance.
400			*/
401	5		private function update($model)
402			{
403	5		$attrs = $this->getMutableAttributes($model);
404	5		$values = array_values($attrs);
405	5		$values[] = $model->{$this->key};
406	5		$this->db
407	5		->connect()
408	5		->update($this->table, array_keys($attrs))
409	5		->where($this->key . ' = ?')
410	5		->execute($values);
			0 ignored issues – show Documentation introduced 2017-10-04 15:29 UTC by Report Bug Copy Issue Report `$values` is of type `array<integer,?>`, but the function expects a `string\|null`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
411	5		}
412
413
414			/**
415			* Get mutable model attributes.
416			*
417			* @param object $model Model instance.
418			*
419			* @return array Array of attributes.
420			*/
421	5		private function getMutableAttributes($model)
422			{
423	5		$attrs = get_object_vars($model);
424	5		unset($attrs[$this->key]);
425
426			// remove reference attributes, if any
427	5		if ($model instanceof ManagedModelInterface) {
428	2		foreach (array_keys($model->getReferences()) as $ref) {
429	2		unset($attrs[$ref]);
430	2		}
431	2		}
432
433	5		return $attrs;
434			}
435			}
436

lrc-se / bth-anax-repository