RDS\Hydrogen\Query\ExecutionsProvider

Complexity

Total Complexity

21

Size/Duplication

Total Lines	167
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

74.55%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	get()	0	20	5
A	pluck()	0	6	1
A	scalar()	0	13	2
B	cast()	0	26	6
A	count()	0	5	1
A	sum()	0	5	1
A	avg()	0	5	1
A	max()	0	5	1
A	min()	0	5	1
A	collect()	0	4	1
A	first()	0	4	1

<?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();

It seems like getRepository() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        if (\count($fields)) {
            return \collect($processor->getArrayResult($this))->map(function (array $data) use ($fields) {
                if (isset($data[0]) && \is_array($data[0])) {
                    $data = $data[0];
                }

                if (\count($fields)) {
                    return Arr::only($data, $fields);
                }

                return $data;
            });
        }

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

    /**
     * Get the values of a given key.
     *
     * @param string|array $value
     * @param string|null $key
     * @return Collection|iterable
     */
    public function pluck($value, $key = null): Collection
    {
        return $this

The method pluck does not exist on object<RDS\Hydrogen\Collection\Collection>? Since you implemented __call, maybe consider adding a @method annotation.

            ->collect(...\array_filter([$value, $key]))
            ->pluck($value, $key);
    }

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

It seems like getRepository() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $result = \array_first($processor->getArrayResult((clone $this)->limit(1)));

It seems like limit() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $result = \data_get($result, $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')

It seems like select() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            ->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')

It seems like select() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            ->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')

It seems like select() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            ->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')

It seems like select() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            ->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')

It seems like select() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            ->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));
    }
}