Repository - Code Metrics - Inspection of "Drop multi type repository support" - ongr-io/ElasticsearchBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#513)

by Mantas

created 2015-12-29 08:50 UTC

Repository B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	400
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes	7
Bugs	0	Features	0

Metric	Value
wmc	41
c	7
b	0
f	0
lcom	1
cbo	9
dl	0
loc	400
rs	8.2769

17 Methods

Rating	Name	Size	Complexity
A	__construct()	15	3
A	getManager()	4	1
A	getType()	4	1
A	find()	20	3
B	findBy()	28	6
B	findOneBy()	16	5
A	createSearch()	4	1
A	execute()	8	1
A	count()	21	2
A	deleteByQuery()	13	1
A	scroll()	9	1
A	remove()	12	1
A	update()	21	1
A	resolveType()	4	1
B	parseResult()	21	6
B	convertToNormalizedArray()	20	6
A	getClassName()	4	1

How to fix Complexity

<?php

/*
 * This file is part of the ONGR package.
 *
 * (c) NFQ Technologies UAB <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace ONGR\ElasticsearchBundle\Service;

use Elasticsearch\Common\Exceptions\Missing404Exception;
use ONGR\ElasticsearchBundle\Result\AbstractResultsIterator;
use ONGR\ElasticsearchBundle\Result\RawIterator;
use ONGR\ElasticsearchDSL\Query\QueryStringQuery;
use ONGR\ElasticsearchDSL\Search;
use ONGR\ElasticsearchDSL\Sort\FieldSort;
use ONGR\ElasticsearchBundle\Result\DocumentIterator;

/**
 * Repository class.
 */
class Repository
{
    const RESULTS_ARRAY = 'array';
    const RESULTS_OBJECT = 'object';
    const RESULTS_RAW = 'raw';
    const RESULTS_RAW_ITERATOR = 'raw_iterator';

    /**
     * @var Manager
     */
    private $manager;

    /**
     * @var string Fully qualified class name
     */
    private $className;

    /**
     * @var string Elasticsearch type name
     */
    private $type;

    /**
     * Constructor.
     *
     * @param Manager $manager
     * @param string  $className
     */
    public function __construct($manager, $className)
    {
        if (!is_string($className)) {
            throw new \InvalidArgumentException('Class name must be a string.');
        }

        if (!class_exists($className)) {
            throw new \InvalidArgumentException(
                sprintf('Cannot create repository for non-existing class "%s".', $className)
            );
        }

        $this->manager = $manager;
        $this->type = $this->resolveType($className);
    }

    /**
     * Returns elasticsearch manager used in the repository.
     *
     * @return Manager
     */
    public function getManager()
    {
        return $this->manager;
    }

    /**
     * @return array
     */
    public function getType()
    {
        return $this->type;
    }

    /**
     * Returns a single document data by ID or null if document is not found.
     *
     * @param string $id         Document Id to find.
     * @param string $resultType Result type returned.
     *
     * @return object|null
     *
     * @throws \LogicException
     */
    public function find($id, $resultType = self::RESULTS_OBJECT)
    {
        $params = [
            'index' => $this->getManager()->getIndexName(),
            'type' => $this->type,
            'id' => $id,
        ];

        try {
            $result = $this->getManager()->getClient()->get($params);
        } catch (Missing404Exception $e) {
            return null;
        }

        if ($resultType === self::RESULTS_OBJECT) {
            return $this->getManager()->getConverter()->convertToDocument($result, $this);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }

        return $this->parseResult($result, $resultType, '');
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * Finds entities by a set of criteria.
     *
     * @param array      $criteria   Example: ['group' => ['best', 'worst'], 'job' => 'medic'].
     * @param array|null $orderBy    Example: ['name' => 'ASC', 'surname' => 'DESC'].
     * @param int|null   $limit      Example: 5.
     * @param int|null   $offset     Example: 30.
     * @param string     $resultType Result type returned.
     *
     * @return array|DocumentIterator The objects.
     */
    public function findBy(
        array $criteria,
        array $orderBy = [],
        $limit = null,
        $offset = null,
        $resultType = self::RESULTS_OBJECT
    ) {
        $search = $this->createSearch();

        if ($limit !== null) {
            $search->setSize($limit);
        }
        if ($offset !== null) {
            $search->setFrom($offset);
        }

        foreach ($criteria as $field => $value) {
            $search->addQuery(
                new QueryStringQuery(is_array($value) ? implode(' OR ', $value) : $value, ['default_field' => $field])
            );
        }

        foreach ($orderBy as $field => $direction) {
            $search->addSort(new FieldSort($field, $direction));
        }

        return $this->execute($search, $resultType);
    }

    /**
     * Finds only one entity by a set of criteria.
     *
     * @param array      $criteria   Example: ['group' => ['best', 'worst'], 'job' => 'medic'].
     * @param array|null $orderBy    Example: ['name' => 'ASC', 'surname' => 'DESC'].
     * @param string     $resultType Result type returned.
     *
     * @throws \Exception
     *
     * @return object|null The object.
     */
    public function findOneBy(array $criteria, array $orderBy = [], $resultType = self::RESULTS_OBJECT)
    {
        $result = $this->findBy($criteria, $orderBy, null, null, $resultType);

        switch ($resultType) {
            case self::RESULTS_OBJECT:
            case self::RESULTS_RAW_ITERATOR:
                return $result->first();
            case self::RESULTS_ARRAY:
                return array_shift($result);
            case self::RESULTS_RAW:
                return array_shift($result['hits']['hits']);
            default:
                throw new \Exception('Wrong results type selected');
        }
    }

    /**
     * Returns search instance.
     *
     * @return Search
     */
    public function createSearch()
    {
        return new Search();
    }

    /**
     * Executes given search.
     *
     * @param Search $search
     * @param string $resultsType
     *
     * @return DocumentIterator|RawIterator|array
     *
     * @throws \Exception
     */
    public function execute(Search $search, $resultsType = self::RESULTS_OBJECT)
    {
        $results = $this
            ->getManager()
            ->search([$this->type], $search->toArray(), $search->getQueryParams());

        return $this->parseResult($results, $resultsType, $search->getScroll());
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * Counts documents by given search.
     *
     * @param Search $search
     * @param array  $params
     * @param bool   $returnRaw If set true returns raw response gotten from client.
     *
     * @return int|array
     */
    public function count(Search $search, array $params = [], $returnRaw = false)
    {
        $body = array_merge(
            [
                'index' => $this->getManager()->getIndexName(),
                'type' => $this->type,
                'body' => $search->toArray(),
            ],
            $params
        );

        $results = $this
            ->getManager()
            ->getClient()->count($body);

        if ($returnRaw) {
            return $results;
        } else {
            return $results['count'];
        }
    }

    /**
     * Delete by query.
     *
     * @param Search $search
     *
     * @return array
     */
    public function deleteByQuery(Search $search)
    {
        $params = [
            'index' => $this->getManager()->getIndexName(),
            'type' => $this->type,
            'body' => $search->toArray(),
        ];

        return $this
            ->getManager()
            ->getClient()
            ->deleteByQuery($params);
    }

    /**
     * Fetches next set of results.
     *
     * @param string $scrollId
     * @param string $scrollDuration
     * @param string $resultsType
     *
     * @return AbstractResultsIterator
     *
     * @throws \Exception
     */
    public function scroll(
        $scrollId,
        $scrollDuration = '5m',
        $resultsType = self::RESULTS_OBJECT
    ) {
        $results = $this->getManager()->getClient()->scroll(['scroll_id' => $scrollId, 'scroll' => $scrollDuration]);

        return $this->parseResult($results, $resultsType, $scrollDuration);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * Removes a single document data by ID.
     *
     * @param string $id Document ID to remove.
     *
     * @return array
     *
     * @throws \LogicException
     */
    public function remove($id)
    {
        $params = [
            'index' => $this->getManager()->getIndexName(),
            'type' => $this->type,
            'id' => $id,
        ];

        $response = $this->getManager()->getClient()->delete($params);

        return $response;
    }

    /**
     * Partial document update.
     *
     * @param string $id     Document id to update.
     * @param array  $fields Fields array to update.
     * @param string $script Groovy script to update fields.
     * @param array  $params Additional parameters to pass to the client.
     *
     * @return array
     */
    public function update($id, array $fields = [], $script = null, array $params = [])
    {
        $body = array_filter(
            [
                'doc' => $fields,
                'script' => $script,
            ]
        );

        $params = array_merge(
            [
                'id' => $id,
                'index' => $this->getManager()->getIndexName(),
                'type' => $this->type,
                'body' => $body,
            ],
            $params
        );

        return $this->getManager()->getClient()->update($params);
    }

    /**
     * Resolves elasticsearch type by class name.
     *
     * @param string $className
     *
     * @return array
     */
    private function resolveType($className)
    {
        return $this->getManager()->getMetadataCollector()->getDocumentType($className);
    }

    /**
     * Parses raw result.
     *
     * @param array  $raw
     * @param string $resultsType
     * @param string $scrollDuration
     *
     * @return DocumentIterator|RawIterator|array
     *
     * @throws \Exception
     */
    private function parseResult($raw, $resultsType, $scrollDuration = null)
    {
        $scrollConfig = [];
        if (isset($raw['_scroll_id'])) {
            $scrollConfig['_scroll_id'] = $raw['_scroll_id'];
            $scrollConfig['duration'] = $scrollDuration;
        }

        switch ($resultsType) {
            case self::RESULTS_OBJECT:
                return new DocumentIterator($raw, $this, $scrollConfig);
            case self::RESULTS_ARRAY:
                return $this->convertToNormalizedArray($raw);
            case self::RESULTS_RAW:
                return $raw;
            case self::RESULTS_RAW_ITERATOR:
                return new RawIterator($raw, $this, $scrollConfig);
            default:
                throw new \Exception('Wrong results type selected');
        }
    }

    /**
     * Normalizes response array.
     *
     * @param array $data
     *
     * @return array
     */
    private function convertToNormalizedArray($data)
    {
        if (array_key_exists('_source', $data)) {
            return $data['_source'];
        }

        $output = [];

        if (isset($data['hits']['hits'][0]['_source'])) {
            foreach ($data['hits']['hits'] as $item) {
                $output[] = $item['_source'];
            }
        } elseif (isset($data['hits']['hits'][0]['fields'])) {
            foreach ($data['hits']['hits'] as $item) {
                $output[] = array_map('reset', $item['fields']);
            }
        }

        return $output;
    }

    /**
     * Returns fully qualified class name.
     *
     * @return string
     */
    public function getClassName()
    {
        return $this->className;
    }
}


1			<?php
2
3			/*
4			* This file is part of the ONGR package.
5			*
6			* (c) NFQ Technologies UAB <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace ONGR\ElasticsearchBundle\Service;
13
14			use Elasticsearch\Common\Exceptions\Missing404Exception;
15			use ONGR\ElasticsearchBundle\Result\AbstractResultsIterator;
16			use ONGR\ElasticsearchBundle\Result\RawIterator;
17			use ONGR\ElasticsearchDSL\Query\QueryStringQuery;
18			use ONGR\ElasticsearchDSL\Search;
19			use ONGR\ElasticsearchDSL\Sort\FieldSort;
20			use ONGR\ElasticsearchBundle\Result\DocumentIterator;
21
22			/**
23			* Repository class.
24			*/
25			class Repository
26			{
27			const RESULTS_ARRAY = 'array';
28			const RESULTS_OBJECT = 'object';
29			const RESULTS_RAW = 'raw';
30			const RESULTS_RAW_ITERATOR = 'raw_iterator';
31
32			/**
33			* @var Manager
34			*/
35			private $manager;
36
37			/**
38			* @var string Fully qualified class name
39			*/
40			private $className;
41
42			/**
43			* @var string Elasticsearch type name
44			*/
45			private $type;
46
47			/**
48			* Constructor.
49			*
50			* @param Manager $manager
51			* @param string $className
52			*/
53			public function __construct($manager, $className)
54			{
55			if (!is_string($className)) {
56			throw new \InvalidArgumentException('Class name must be a string.');
57			}
58
59			if (!class_exists($className)) {
60			throw new \InvalidArgumentException(
61			sprintf('Cannot create repository for non-existing class "%s".', $className)
62			);
63			}
64
65			$this->manager = $manager;
66			$this->type = $this->resolveType($className);
67			}
68
69			/**
70			* Returns elasticsearch manager used in the repository.
71			*
72			* @return Manager
73			*/
74			public function getManager()
75			{
76			return $this->manager;
77			}
78
79			/**
80			* @return array
81			*/
82			public function getType()
83			{
84			return $this->type;
85			}
86
87			/**
88			* Returns a single document data by ID or null if document is not found.
89			*
90			* @param string $id Document Id to find.
91			* @param string $resultType Result type returned.
92			*
93			* @return object\|null
94			*
95			* @throws \LogicException
96			*/
97			public function find($id, $resultType = self::RESULTS_OBJECT)
98			{
99			$params = [
100			'index' => $this->getManager()->getIndexName(),
101			'type' => $this->type,
102			'id' => $id,
103			];
104
105			try {
106			$result = $this->getManager()->getClient()->get($params);
107			} catch (Missing404Exception $e) {
108			return null;
109			}
110
111			if ($resultType === self::RESULTS_OBJECT) {
112			return $this->getManager()->getConverter()->convertToDocument($result, $this);
			0 ignored issues – show Documentation introduced 2015-11-23 09:47 UTC by Report Bug Copy Issue Report `$result` is of type `callable`, but the function expects a `array`. 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...
113			}
114
115			return $this->parseResult($result, $resultType, '');
			0 ignored issues – show Documentation introduced 2015-11-23 09:47 UTC by Report Bug Copy Issue Report `$result` is of type `callable`, but the function expects a `array`. 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...
116			}
117
118			/**
119			* Finds entities by a set of criteria.
120			*
121			* @param array $criteria Example: ['group' => ['best', 'worst'], 'job' => 'medic'].
122			* @param array\|null $orderBy Example: ['name' => 'ASC', 'surname' => 'DESC'].
123			* @param int\|null $limit Example: 5.
124			* @param int\|null $offset Example: 30.
125			* @param string $resultType Result type returned.
126			*
127			* @return array\|DocumentIterator The objects.
128			*/
129			public function findBy(
130			array $criteria,
131			array $orderBy = [],
132			$limit = null,
133			$offset = null,
134			$resultType = self::RESULTS_OBJECT
135			) {
136			$search = $this->createSearch();
137
138			if ($limit !== null) {
139			$search->setSize($limit);
140			}
141			if ($offset !== null) {
142			$search->setFrom($offset);
143			}
144
145			foreach ($criteria as $field => $value) {
146			$search->addQuery(
147			new QueryStringQuery(is_array($value) ? implode(' OR ', $value) : $value, ['default_field' => $field])
148			);
149			}
150
151			foreach ($orderBy as $field => $direction) {
152			$search->addSort(new FieldSort($field, $direction));
153			}
154
155			return $this->execute($search, $resultType);
156			}
157
158			/**
159			* Finds only one entity by a set of criteria.
160			*
161			* @param array $criteria Example: ['group' => ['best', 'worst'], 'job' => 'medic'].
162			* @param array\|null $orderBy Example: ['name' => 'ASC', 'surname' => 'DESC'].
163			* @param string $resultType Result type returned.
164			*
165			* @throws \Exception
166			*
167			* @return object\|null The object.
168			*/
169			public function findOneBy(array $criteria, array $orderBy = [], $resultType = self::RESULTS_OBJECT)
170			{
171			$result = $this->findBy($criteria, $orderBy, null, null, $resultType);
172
173			switch ($resultType) {
174			case self::RESULTS_OBJECT:
175			case self::RESULTS_RAW_ITERATOR:
176			return $result->first();
177			case self::RESULTS_ARRAY:
178			return array_shift($result);
179			case self::RESULTS_RAW:
180			return array_shift($result['hits']['hits']);
181			default:
182			throw new \Exception('Wrong results type selected');
183			}
184			}
185
186			/**
187			* Returns search instance.
188			*
189			* @return Search
190			*/
191			public function createSearch()
192			{
193			return new Search();
194			}
195
196			/**
197			* Executes given search.
198			*
199			* @param Search $search
200			* @param string $resultsType
201			*
202			* @return DocumentIterator\|RawIterator\|array
203			*
204			* @throws \Exception
205			*/
206			public function execute(Search $search, $resultsType = self::RESULTS_OBJECT)
207			{
208			$results = $this
209			->getManager()
210			->search([$this->type], $search->toArray(), $search->getQueryParams());
211
212			return $this->parseResult($results, $resultsType, $search->getScroll());
			0 ignored issues – show Documentation introduced 2015-11-23 09:47 UTC by Report Bug Copy Issue Report `$results` is of type `callable`, but the function expects a `array`. 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...
213			}
214
215			/**
216			* Counts documents by given search.
217			*
218			* @param Search $search
219			* @param array $params
220			* @param bool $returnRaw If set true returns raw response gotten from client.
221			*
222			* @return int\|array
223			*/
224			public function count(Search $search, array $params = [], $returnRaw = false)
225			{
226			$body = array_merge(
227			[
228			'index' => $this->getManager()->getIndexName(),
229			'type' => $this->type,
230			'body' => $search->toArray(),
231			],
232			$params
233			);
234
235			$results = $this
236			->getManager()
237			->getClient()->count($body);
238
239			if ($returnRaw) {
240			return $results;
241			} else {
242			return $results['count'];
243			}
244			}
245
246			/**
247			* Delete by query.
248			*
249			* @param Search $search
250			*
251			* @return array
252			*/
253			public function deleteByQuery(Search $search)
254			{
255			$params = [
256			'index' => $this->getManager()->getIndexName(),
257			'type' => $this->type,
258			'body' => $search->toArray(),
259			];
260
261			return $this
262			->getManager()
263			->getClient()
264			->deleteByQuery($params);
265			}
266
267			/**
268			* Fetches next set of results.
269			*
270			* @param string $scrollId
271			* @param string $scrollDuration
272			* @param string $resultsType
273			*
274			* @return AbstractResultsIterator
275			*
276			* @throws \Exception
277			*/
278			public function scroll(
279			$scrollId,
280			$scrollDuration = '5m',
281			$resultsType = self::RESULTS_OBJECT
282			) {
283			$results = $this->getManager()->getClient()->scroll(['scroll_id' => $scrollId, 'scroll' => $scrollDuration]);
284
285			return $this->parseResult($results, $resultsType, $scrollDuration);
			0 ignored issues – show Documentation introduced 2015-11-23 09:47 UTC by Report Bug Copy Issue Report `$results` is of type `callable`, but the function expects a `array`. 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...
286			}
287
288			/**
289			* Removes a single document data by ID.
290			*
291			* @param string $id Document ID to remove.
292			*
293			* @return array
294			*
295			* @throws \LogicException
296			*/
297			public function remove($id)
298			{
299			$params = [
300			'index' => $this->getManager()->getIndexName(),
301			'type' => $this->type,
302			'id' => $id,
303			];
304
305			$response = $this->getManager()->getClient()->delete($params);
306
307			return $response;
308			}
309
310			/**
311			* Partial document update.
312			*
313			* @param string $id Document id to update.
314			* @param array $fields Fields array to update.
315			* @param string $script Groovy script to update fields.
316			* @param array $params Additional parameters to pass to the client.
317			*
318			* @return array
319			*/
320			public function update($id, array $fields = [], $script = null, array $params = [])
321			{
322			$body = array_filter(
323			[
324			'doc' => $fields,
325			'script' => $script,
326			]
327			);
328
329			$params = array_merge(
330			[
331			'id' => $id,
332			'index' => $this->getManager()->getIndexName(),
333			'type' => $this->type,
334			'body' => $body,
335			],
336			$params
337			);
338
339			return $this->getManager()->getClient()->update($params);
340			}
341
342			/**
343			* Resolves elasticsearch type by class name.
344			*
345			* @param string $className
346			*
347			* @return array
348			*/
349			private function resolveType($className)
350			{
351			return $this->getManager()->getMetadataCollector()->getDocumentType($className);
352			}
353
354			/**
355			* Parses raw result.
356			*
357			* @param array $raw
358			* @param string $resultsType
359			* @param string $scrollDuration
360			*
361			* @return DocumentIterator\|RawIterator\|array
362			*
363			* @throws \Exception
364			*/
365			private function parseResult($raw, $resultsType, $scrollDuration = null)
366			{
367			$scrollConfig = [];
368			if (isset($raw['_scroll_id'])) {
369			$scrollConfig['_scroll_id'] = $raw['_scroll_id'];
370			$scrollConfig['duration'] = $scrollDuration;
371			}
372
373			switch ($resultsType) {
374			case self::RESULTS_OBJECT:
375			return new DocumentIterator($raw, $this, $scrollConfig);
376			case self::RESULTS_ARRAY:
377			return $this->convertToNormalizedArray($raw);
378			case self::RESULTS_RAW:
379			return $raw;
380			case self::RESULTS_RAW_ITERATOR:
381			return new RawIterator($raw, $this, $scrollConfig);
382			default:
383			throw new \Exception('Wrong results type selected');
384			}
385			}
386
387			/**
388			* Normalizes response array.
389			*
390			* @param array $data
391			*
392			* @return array
393			*/
394			private function convertToNormalizedArray($data)
395			{
396			if (array_key_exists('_source', $data)) {
397			return $data['_source'];
398			}
399
400			$output = [];
401
402			if (isset($data['hits']['hits'][0]['_source'])) {
403			foreach ($data['hits']['hits'] as $item) {
404			$output[] = $item['_source'];
405			}
406			} elseif (isset($data['hits']['hits'][0]['fields'])) {
407			foreach ($data['hits']['hits'] as $item) {
408			$output[] = array_map('reset', $item['fields']);
409			}
410			}
411
412			return $output;
413			}
414
415			/**
416			* Returns fully qualified class name.
417			*
418			* @return string
419			*/
420			public function getClassName()
421			{
422			return $this->className;
423			}
424			}
425

ongr-io / ElasticsearchBundle

Pull Request — master (#513)

Repository B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

17 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like