RDS\Hydrogen\Query\ExecutionsProvider

Complexity

Total Complexity

19

Size/Duplication

Total Lines	165
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

70.59%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	get()	0	6	1
A	pluck()	0	7	1
A	scalar()	0	12	2
B	cast()	0	29	7
A	count()	0	10	2
A	sum()	0	6	1
A	avg()	0	6	1
A	max()	0	6	1
A	min()	0	6	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?

        return $processor->getResult($this, ...$fields);
    }

    /**
     * Get the values of a given key.
     *
     * @param string|array $value
     * @param string|null $key
     * @return Collection|iterable
     */
    public function pluck($value, $key = null): array
    {
        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)
            ->toArray();
    }

    /**
     * @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 = $processor->getScalarResult($this, $field);

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

        return $result;
    }

    /**
     * @param mixed $result
     * @param string $typeOf
     * @return array|\Closure|object|mixed
     */
    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;

            case 'string':
                return (string)$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 = null): int
    {
        if ($field === null) {
            $field = \array_first($this->getMetadata()->identifier);

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

        }

        return $this

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

            ->select('COUNT(' . $field . ') AS __count')
            ->scalar('__count', 'int');
    }

    /**
     * @param string|null $field
     * @return int
     * @throws \LogicException
     */
    public function sum(string $field = null): int
    {
        return $this

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

            ->select('SUM(' . $field . ') AS __sum')
            ->scalar('__sum', 'int');
    }

    /**
     * @param string|null $field
     * @return int
     * @throws \LogicException
     */
    public function avg(string $field = null): int
    {
        return $this

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

            ->select('AVG(' . $field . ') AS __avg')
            ->scalar('__avg', 'int');
    }

    /**
     * @param string|null $field
     * @return int
     * @throws \LogicException
     */
    public function max(string $field = null): int
    {
        return $this

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

            ->select('MAX(' . $field . ') AS __max')
            ->scalar('__max', 'int');
    }

    /**
     * @param string|null $field
     * @return int
     * @throws \LogicException
     */
    public function min(string $field = null): int
    {
        return $this

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

            ->select('MIN(' . $field . ') AS __min')
            ->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));
    }
}