ExecutionsProvider::get() - Code Metrics - Inspection of "Add join logic" - rambler-digital-solutions/hydrogen - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( c80e12...1c5165 )

by Kirill

created 2018-09-03 13:15 UTC

ExecutionsProvider::get() A

↳ Parent: ExecutionsProvider

Complexity

Conditions	3
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	3.0123

Importance

Changes

Metric	Value
dl	0
loc	16
ccs	8
cts	9
cp	0.8889
rs	9.7333
c	0
b	0
f	0
cc	3
nc	2
nop	1
crap	3.0123

<?php
/**
 * This file is part of Hydrogen package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
declare(strict_types=1);

namespace RDS\Hydrogen\Query;

use Illuminate\Support\Arr;
use RDS\Hydrogen\Query;
use RDS\Hydrogen\Collection\Collection;

/**
 * Class ExecutionsProvider
 * @mixin Query
 */
trait ExecutionsProvider
{
    /**
     * @param string ...$fields
     * @return object[]|iterable
     */
    public function get(string ...$fields): iterable
    {
        $processor = $this->getRepository()->getProcessor();
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

        if (\count($fields)) {
            return \collect($processor->getArrayResult($this))->map(function (array $data) use ($fields) {
                if (\count($fields)) {
                    return Arr::only($data, $fields);
                }

                return $data;
            });
        }

        return $processor->getResult($this);
    }

    /**
     * @param string $field
     * @param string|null $typeOf
     * @return mixed
     * @throws \LogicException
     */
    public function scalar(string $field, string $typeOf = null)
    {
        $result = \data_get($this->first($field), $field);

        if ($typeOf !== null) {
            return $this->cast($result, $typeOf);
        }

        return $result;
    }

    /**
     * @param mixed $result
     * @param string $typeOf
     * @return array|\Closure|object
     */
    private function cast($result, string $typeOf)
    {
        $typeOf = \strtolower($typeOf);

        switch ($typeOf) {
            case 'callable':
                return function (callable $applicator = null) use ($result) {
                    return ($applicator ?? '\\value')($result);
                };

            case 'object':
                return (object)$result;

            case 'array':
            case 'iterable':
                return (array)$result;
        }

        $function = $typeOf . 'val';

        if (! \function_exists($function)) {
            throw new \InvalidArgumentException('Could not cast to type ' . $typeOf);
        }

        return $function($result);
    }

    /**
     * @param string|null $field
     * @return int
     * @throws \LogicException
     */
    public function count(?string $field = 'id'): int
    {
        return $this->select('COUNT(' . $field . ') AS __count')
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->scalar('__count', 'int');
    }

    /**
     * @param string|null $field
     * @return int
     * @throws \LogicException
     */
    public function sum(string $field = null): int
    {
        return $this->select('SUM(' . $field . ') AS __sum')
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->scalar('__sum', 'int');
    }

    /**
     * @param string|null $field
     * @return int
     * @throws \LogicException
     */
    public function avg(string $field = null): int
    {
        return $this->select('AVG(' . $field . ') AS __avg')
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->scalar('__avg', 'int');
    }

    /**
     * @param string|null $field
     * @return int
     * @throws \LogicException
     */
    public function max(string $field = null): int
    {
        return $this->select('MAX(' . $field . ') AS __max')
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->scalar('__max', 'int');
    }

    /**
     * @param string|null $field
     * @return int
     * @throws \LogicException
     */
    public function min(string $field = null): int
    {
        return $this->select('MIN(' . $field . ') AS __min')
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->scalar('__min', 'int');
    }

    /**
     * @param string ...$fields
     * @return Collection
     */
    public function collect(string ...$fields): Collection
    {
        return Collection::wrap($this->get(...$fields));
    }

    /**
     * @param string[] $fields
     * @return object|null
     * @throws \LogicException
     */
    public function first(string ...$fields)
    {
        return \array_first($this->get(...$fields));
    }
}


1		<?php
2		/**
3		* This file is part of Hydrogen package.
4		*
5		* For the full copyright and license information, please view the LICENSE
6		* file that was distributed with this source code.
7		*/
8		declare(strict_types=1);
9
10		namespace RDS\Hydrogen\Query;
11
12		use Illuminate\Support\Arr;
13		use RDS\Hydrogen\Query;
14		use RDS\Hydrogen\Collection\Collection;
15
16		/**
17		* Class ExecutionsProvider
18		* @mixin Query
19		*/
20		trait ExecutionsProvider
21		{
22		/**
23		* @param string ...$fields
24		* @return object[]\|iterable
25		*/
26	30	public function get(string ...$fields): iterable
27		{
28	30	$processor = $this->getRepository()->getProcessor();
		0 ignored issues – show Bug introduced 2018-09-02 05:50 UTC by Report Bug Copy Issue Report It seems like `getRepository()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
29
30	30	if (\count($fields)) {
31	12	return \collect($processor->getArrayResult($this))->map(function (array $data) use ($fields) {
32	12	if (\count($fields)) {
33	12	return Arr::only($data, $fields);
34		}
35
36		return $data;
37	12	});
38		}
39
40	20	return $processor->getResult($this);
41		}
42
43		/**
44		* @param string $field
45		* @param string\|null $typeOf
46		* @return mixed
47		* @throws \LogicException
48		*/
49	10	public function scalar(string $field, string $typeOf = null)
50		{
51	10	$result = \data_get($this->first($field), $field);
52
53	10	if ($typeOf !== null) {
54	10	return $this->cast($result, $typeOf);
55		}
56
57		return $result;
58		}
59
60		/**
61		* @param mixed $result
62		* @param string $typeOf
63		* @return array\|\Closure\|object
64		*/
65	10	private function cast($result, string $typeOf)
66		{
67	10	$typeOf = \strtolower($typeOf);
68
69		switch ($typeOf) {
70	10	case 'callable':
71		return function (callable $applicator = null) use ($result) {
72		return ($applicator ?? '\\value')($result);
73		};
74
75	10	case 'object':
76		return (object)$result;
77
78	10	case 'array':
79	10	case 'iterable':
80		return (array)$result;
81		}
82
83	10	$function = $typeOf . 'val';
84
85	10	if (! \function_exists($function)) {
86		throw new \InvalidArgumentException('Could not cast to type ' . $typeOf);
87		}
88
89	10	return $function($result);
90		}
91
92		/**
93		* @param string\|null $field
94		* @return int
95		* @throws \LogicException
96		*/
97	2	public function count(?string $field = 'id'): int
98		{
99	2	return $this->select('COUNT(' . $field . ') AS __count')
		0 ignored issues – show Bug introduced 2018-09-02 05:50 UTC by Report Bug Copy Issue Report It seems like `select()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
100	2	->scalar('__count', 'int');
101		}
102
103		/**
104		* @param string\|null $field
105		* @return int
106		* @throws \LogicException
107		*/
108	2	public function sum(string $field = null): int
109		{
110	2	return $this->select('SUM(' . $field . ') AS __sum')
		0 ignored issues – show Bug introduced 2018-09-02 05:50 UTC by Report Bug Copy Issue Report It seems like `select()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
111	2	->scalar('__sum', 'int');
112		}
113
114		/**
115		* @param string\|null $field
116		* @return int
117		* @throws \LogicException
118		*/
119	2	public function avg(string $field = null): int
120		{
121	2	return $this->select('AVG(' . $field . ') AS __avg')
		0 ignored issues – show Bug introduced 2018-09-02 05:50 UTC by Report Bug Copy Issue Report It seems like `select()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
122	2	->scalar('__avg', 'int');
123		}
124
125		/**
126		* @param string\|null $field
127		* @return int
128		* @throws \LogicException
129		*/
130	2	public function max(string $field = null): int
131		{
132	2	return $this->select('MAX(' . $field . ') AS __max')
		0 ignored issues – show Bug introduced 2018-09-02 05:50 UTC by Report Bug Copy Issue Report It seems like `select()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
133	2	->scalar('__max', 'int');
134		}
135
136		/**
137		* @param string\|null $field
138		* @return int
139		* @throws \LogicException
140		*/
141	2	public function min(string $field = null): int
142		{
143	2	return $this->select('MIN(' . $field . ') AS __min')
		0 ignored issues – show Bug introduced 2018-09-02 05:50 UTC by Report Bug Copy Issue Report It seems like `select()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
144	2	->scalar('__min', 'int');
145		}
146
147		/**
148		* @param string ...$fields
149		* @return Collection
150		*/
151	2	public function collect(string ...$fields): Collection
152		{
153	2	return Collection::wrap($this->get(...$fields));
154		}
155
156		/**
157		* @param string[] $fields
158		* @return object\|null
159		* @throws \LogicException
160		*/
161	10	public function first(string ...$fields)
162		{
163	10	return \array_first($this->get(...$fields));
164		}
165		}
166

rambler-digital-solutions / hydrogen

Push — master ( c80e12...1c5165 )

ExecutionsProvider::get() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like