AbstractSqlRepository::getEntityRelationships() - Code Metrics - Inspection of "Relationship improvement" - acredula/percy - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 23ff15...beb2ae )

by Phil

created 2016-01-08 11:28 UTC

AbstractSqlRepository::getEntityRelationships() B

↳ Parent: AbstractSqlRepository

Complexity

Conditions	2
Paths	2

Size

Total Lines	30
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	30
ccs	0
cts	24
cp	0
rs	8.8571
cc	2
eloc	20
nc	2
nop	4
crap	6

<?php

namespace Percy\Repository;

use Aura\Sql\ExtendedPdoInterface;
use InvalidArgumentException;
use Percy\Entity\Collection;
use Percy\Entity\CollectionBuilderTrait;
use Percy\Entity\EntityInterface;
use Percy\Http\QueryStringParserTrait;
use Psr\Http\Message\ServerRequestInterface;
use RuntimeException;

abstract class AbstractSqlRepository implements RepositoryInterface
{
    use CollectionBuilderTrait;
    use QueryStringParserTrait;

    /**
     * @var \Aura\Sql\ExtendedPdoInterface
     */
    protected $dbal;

    /**
     *
     * @var mixed
     */
    protected $relationships = [];

    /**
     * Construct.
     *
     * @param \Aura\Sql\ExtendedPdoInterface $dbal
     */
    public function __construct(ExtendedPdoInterface $dbal)
    {
        $this->dbal = $dbal;
    }

    /**
     * {@inheritdoc}
     */
    public function countFromRequest(ServerRequestInterface $request)
    {
        $rules = $this->parseQueryString($request->getUri()->getQuery());
        list($query, $params) = $this->buildQueryFromRules($rules, 'SELECT COUNT(*) as total FROM ');

        return (int) $this->dbal->fetchOne($query, $params)['total'];
    }

    /**
     * {@inheritdoc}
     */
    public function getFromRequest(ServerRequestInterface $request)
    {
        $rules = $this->parseQueryString($request->getUri()->getQuery());

        list($query, $params) = $this->buildQueryFromRules($rules);

        if (array_key_exists('sort', $rules)) {
            $query .= sprintf(' ORDER BY %s ', $rules['sort']);
            $query .= (array_key_exists('sort_direction', $rules)) ? $rules['sort_direction'] : 'ASC';
        }

        if (array_key_exists('limit', $rules)) {
            $query .= ' LIMIT ';
            $query .= (array_key_exists('offset', $rules)) ? sprintf('%d,', $rules['offset']) : '';
            $query .= $rules['limit'];
        }

        return $this->buildCollection($this->dbal->fetchAll($query, $params))
                    ->setTotal($this->countFromRequest($request));
    }

    /**
     * Build a base query without sorting and limits from filter rules.
     *
     * @param array  $rules
     * @param string $start
     *
     * @return array
     */
    protected function buildQueryFromRules(array $rules, $start = 'SELECT * FROM ')
    {
        $query = $start . $this->getTable();

        $params = [];

        if (array_key_exists('filter', $rules)) {
            foreach ($rules['filter'] as $key => $where) {
                $keyword = ($key === 0) ? ' WHERE' : ' AND';
                $query  .= sprintf('%s %s %s :%s', $keyword, $where['field'], $where['delimiter'], $where['field']);

                $params[$where['field']] = $where['value'];
            }
        }

        return [$query, $params];
    }

    /**
     * {@inheritdoc}
     */
    public function countByField($field, $value)
    {
        $query = sprintf('SELECT COUNT(*) as total FROM %s WHERE %s IN (:%s)', $this->getTable(), $field, $field);

        $params = [
            $field => implode(',', (array) $value)
        ];

        return (int) $this->dbal->fetchOne($query, $params)['total'];
    }

    /**
     * {@inheritdoc}
     */
    public function getByField($field, $value)
    {
        $query = sprintf('SELECT * FROM %s WHERE %s IN (:%s)', $this->getTable(), $field, $field);

        $params = [
            $field => implode(',', (array) $value)
        ];

        return $this->buildCollection($this->dbal->fetchAll($query, $params))
                    ->setTotal($this->countByField($field, $value));
    }

    /**
     * {@inheritdoc}
     */
    public function getRelationshipsFor(Collection $collection, array $relationships = [])
    {
        $relationsips = new Collection;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $entities     = [];

        foreach ($collection->getIterator() as $entity) {
            array_walk($entity->getRelationships(), [$this, 'getEntityRelationships'], $entity, $entities);

        }

        foreach ($entities as $entity) {
            $relationships->addEntity($entity);

        }

        return $relationships;
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());
}
    }

    /**
     * Attach relationships to a specific entity.
     *
     * @param string                        $entityType
     * @param string                        $relationship
     * @param \Percy\Entity\EntityInterface $entity
     * @param array                         $entities
     *
     * @return void
     */
    protected function getEntityRelationships($entityType, $relationship, EntityInterface $entity, array &$entities)
    {
        $map = $this->getRelationshipMap($relationship);

        $query = sprintf(
            'SELECT * FROM %s LEFT JOIN %s ON %s.%s = %s.%s WHERE %s = :%s',
            $map['defined_in']['table'],
            $map['target']['table'],
            $map['target']['table'],
            $map['target']['primary'],
            $map['defined_in']['table'],
            $map['target']['relationship'],
            $map['defined_in']['primary'],
            $map['defined_in']['entity']
        );

        $result = $this->dbal->fetchAll($query, [
            $map['defined_in']['entity'] => $entity[$map['defined_in']['entity']]
        ]);

        $remove = [$map['defined_in']['primary'], $map['target']['relationship']];

        foreach ($result as $resource) {
            $resource = array_filter($resource, function ($key) use ($remove) {
                return (! in_array($key, $remove));
            }, ARRAY_FILTER_USE_KEY);

            $entities[] = (new $entityType)->hydrate($resource);
        }
    }

    /**
     * Get possible relationships and the properties attached to them.
     *
     * @param string $relationship
     *
     * @throws \InvalidArgumentException when requested relationship is not defined
     * @throws \RuntimeException when map structure is defined incorrectly
     *
     * @return array
     */
    protected function getRelationshipMap($relationship)
    {
        if (! array_key_exists($relationship, $this->relationships)) {
            throw new InvalidArgumentException(
                sprintf('(%s) is not defined in the relationship map on (%s)', $relationship, get_class($this))
            );
        }

        $map = $this->relationships[$relationship];

        foreach ([
            'defined_in' => ['table', 'primary', 'entity'],
            'target'     => ['table', 'primary', 'relationship']
        ] as $key => $value) {
            if (! array_key_exists($key, $map) || ! is_array($map[$key])) {
                throw new RuntimeException(
                    sprintf(
                        'Relationship (%s) should contain the (%s) key and should be of type array on (%s)',
                        $relationship, $key, get_class($this)
                    )
                );
            }

            if (! empty(array_diff($value, array_keys($map[$key])))) {
                throw new RuntimeException(
                    sprintf(
                        '(%s) for relationship (%s) should contain keys (%s) on (%s)',
                        $key, $relationship, implode(', ', $value), get_class($this)
                    )
                );
            }
        }

        return $map;
    }

    /**
     * Returns table that repository is reading from.
     *
     * @return string
     */
    abstract protected function getTable();
}


1		<?php
2
3		namespace Percy\Repository;
4
5		use Aura\Sql\ExtendedPdoInterface;
6		use InvalidArgumentException;
7		use Percy\Entity\Collection;
8		use Percy\Entity\CollectionBuilderTrait;
9		use Percy\Entity\EntityInterface;
10		use Percy\Http\QueryStringParserTrait;
11		use Psr\Http\Message\ServerRequestInterface;
12		use RuntimeException;
13
14		abstract class AbstractSqlRepository implements RepositoryInterface
15		{
16		use CollectionBuilderTrait;
17		use QueryStringParserTrait;
18
19		/**
20		* @var \Aura\Sql\ExtendedPdoInterface
21		*/
22		protected $dbal;
23
24		/**
25		*
26		* @var mixed
27		*/
28		protected $relationships = [];
29
30		/**
31		* Construct.
32		*
33		* @param \Aura\Sql\ExtendedPdoInterface $dbal
34		*/
35	2	public function __construct(ExtendedPdoInterface $dbal)
36		{
37	2	$this->dbal = $dbal;
38	2	}
39
40		/**
41		* {@inheritdoc}
42		*/
43	1	public function countFromRequest(ServerRequestInterface $request)
44		{
45	1	$rules = $this->parseQueryString($request->getUri()->getQuery());
46	1	list($query, $params) = $this->buildQueryFromRules($rules, 'SELECT COUNT(*) as total FROM ');
47
48	1	return (int) $this->dbal->fetchOne($query, $params)['total'];
49		}
50
51		/**
52		* {@inheritdoc}
53		*/
54	1	public function getFromRequest(ServerRequestInterface $request)
55		{
56	1	$rules = $this->parseQueryString($request->getUri()->getQuery());
57
58	1	list($query, $params) = $this->buildQueryFromRules($rules);
59
60	1	if (array_key_exists('sort', $rules)) {
61	1	$query .= sprintf(' ORDER BY %s ', $rules['sort']);
62	1	$query .= (array_key_exists('sort_direction', $rules)) ? $rules['sort_direction'] : 'ASC';
63	1	}
64
65	1	if (array_key_exists('limit', $rules)) {
66	1	$query .= ' LIMIT ';
67	1	$query .= (array_key_exists('offset', $rules)) ? sprintf('%d,', $rules['offset']) : '';
68	1	$query .= $rules['limit'];
69	1	}
70
71	1	return $this->buildCollection($this->dbal->fetchAll($query, $params))
72	1	->setTotal($this->countFromRequest($request));
73		}
74
75		/**
76		* Build a base query without sorting and limits from filter rules.
77		*
78		* @param array $rules
79		* @param string $start
80		*
81		* @return array
82		*/
83	1	protected function buildQueryFromRules(array $rules, $start = 'SELECT * FROM ')
84		{
85	1	$query = $start . $this->getTable();
86
87	1	$params = [];
88
89	1	if (array_key_exists('filter', $rules)) {
90	1	foreach ($rules['filter'] as $key => $where) {
91	1	$keyword = ($key === 0) ? ' WHERE' : ' AND';
92	1	$query .= sprintf('%s %s %s :%s', $keyword, $where['field'], $where['delimiter'], $where['field']);
93
94	1	$params[$where['field']] = $where['value'];
95	1	}
96	1	}
97
98	1	return [$query, $params];
99		}
100
101		/**
102		* {@inheritdoc}
103		*/
104	1	public function countByField($field, $value)
105		{
106	1	$query = sprintf('SELECT COUNT(*) as total FROM %s WHERE %s IN (:%s)', $this->getTable(), $field, $field);
107
108		$params = [
109	1	$field => implode(',', (array) $value)
110	1	];
111
112	1	return (int) $this->dbal->fetchOne($query, $params)['total'];
113		}
114
115		/**
116		* {@inheritdoc}
117		*/
118	1	public function getByField($field, $value)
119		{
120	1	$query = sprintf('SELECT * FROM %s WHERE %s IN (:%s)', $this->getTable(), $field, $field);
121
122		$params = [
123	1	$field => implode(',', (array) $value)
124	1	];
125
126	1	return $this->buildCollection($this->dbal->fetchAll($query, $params))
127	1	->setTotal($this->countByField($field, $value));
128		}
129
130		/**
131		* {@inheritdoc}
132		*/
133		public function getRelationshipsFor(Collection $collection, array $relationships = [])
134		{
135		$relationsips = new Collection;
		0 ignored issues – show Unused Code introduced 2016-01-08 11:33 UTC by Report Bug Copy Issue Report `$relationsips` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
136		$entities = [];
137
138		foreach ($collection->getIterator() as $entity) {
139		array_walk($entity->getRelationships(), [$this, 'getEntityRelationships'], $entity, $entities);
		0 ignored issues – show Bug introduced 2016-01-08 11:33 UTC by Report Bug Copy Issue Report `$entity->getRelationships()` cannot be passed to `array_walk()` as the parameter `$array` expects a reference. Loading history...
140		}
141
142		foreach ($entities as $entity) {
143		$relationships->addEntity($entity);
		0 ignored issues – show Bug introduced 2016-01-08 11:33 UTC by Report Bug Copy Issue Report The method `addEntity` cannot be called on `$relationships` (of type `array`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
144		}
145
146		return $relationships;
		0 ignored issues – show Bug Best Practice introduced 2016-01-08 11:33 UTC by Report Bug Copy Issue Report The return type of `return $relationships;` (`array`) is incompatible with the return type declared by the interface `Percy\Repository\Reposit...ce::getRelationshipsFor` of type `Percy\Entity\Collection`. 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...
147		}
148
149		/**
150		* Attach relationships to a specific entity.
151		*
152		* @param string $entityType
153		* @param string $relationship
154		* @param \Percy\Entity\EntityInterface $entity
155		* @param array $entities
156		*
157		* @return void
158		*/
159		protected function getEntityRelationships($entityType, $relationship, EntityInterface $entity, array &$entities)
160		{
161		$map = $this->getRelationshipMap($relationship);
162
163		$query = sprintf(
164		'SELECT * FROM %s LEFT JOIN %s ON %s.%s = %s.%s WHERE %s = :%s',
165		$map['defined_in']['table'],
166		$map['target']['table'],
167		$map['target']['table'],
168		$map['target']['primary'],
169		$map['defined_in']['table'],
170		$map['target']['relationship'],
171		$map['defined_in']['primary'],
172		$map['defined_in']['entity']
173		);
174
175		$result = $this->dbal->fetchAll($query, [
176		$map['defined_in']['entity'] => $entity[$map['defined_in']['entity']]
177		]);
178
179		$remove = [$map['defined_in']['primary'], $map['target']['relationship']];
180
181		foreach ($result as $resource) {
182		$resource = array_filter($resource, function ($key) use ($remove) {
183		return (! in_array($key, $remove));
184		}, ARRAY_FILTER_USE_KEY);
185
186		$entities[] = (new $entityType)->hydrate($resource);
187		}
188		}
189
190		/**
191		* Get possible relationships and the properties attached to them.
192		*
193		* @param string $relationship
194		*
195		* @throws \InvalidArgumentException when requested relationship is not defined
196		* @throws \RuntimeException when map structure is defined incorrectly
197		*
198		* @return array
199		*/
200		protected function getRelationshipMap($relationship)
201		{
202		if (! array_key_exists($relationship, $this->relationships)) {
203		throw new InvalidArgumentException(
204		sprintf('(%s) is not defined in the relationship map on (%s)', $relationship, get_class($this))
205		);
206		}
207
208		$map = $this->relationships[$relationship];
209
210		foreach ([
211		'defined_in' => ['table', 'primary', 'entity'],
212		'target' => ['table', 'primary', 'relationship']
213		] as $key => $value) {
214		if (! array_key_exists($key, $map) \|\| ! is_array($map[$key])) {
215		throw new RuntimeException(
216		sprintf(
217		'Relationship (%s) should contain the (%s) key and should be of type array on (%s)',
218		$relationship, $key, get_class($this)
219		)
220		);
221		}
222
223		if (! empty(array_diff($value, array_keys($map[$key])))) {
224		throw new RuntimeException(
225		sprintf(
226		'(%s) for relationship (%s) should contain keys (%s) on (%s)',
227		$key, $relationship, implode(', ', $value), get_class($this)
228		)
229		);
230		}
231		}
232
233		return $map;
234		}
235
236		/**
237		* Returns table that repository is reading from.
238		*
239		* @return string
240		*/
241		abstract protected function getTable();
242		}
243

acredula / percy

Push — master ( 23ff15...beb2ae )

AbstractSqlRepository::getEntityRelationships() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like