RDS\Hydrogen\HighOrderMessaging\HigherOrderCollectionProxy

Complexity

Total Complexity

28

Size/Duplication

Total Lines	163
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	1

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
B	__get()	0	26	6
B	__call()	0	26	6
A	isArrayable()	0	4	2
A	hasCallableKey()	0	4	2
A	hasProperty()	0	7	3
A	hasCallableProperty()	0	4	2
A	hasMethod()	0	7	3
A	pack()	0	10	3

<?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\HighOrderMessaging;

use Illuminate\Support\Str;
use RDS\Hydrogen\Collection;

/**
 * Class HigherOrderCollectionProxy
 */
class HigherOrderCollectionProxy
{
    /**
     * This pattern is used to specify the location of the delegate in
     * the function arguments in the high-order messaging.
     */
    public const PATTERN = '_';

    /**
     * @var Collection
     */
    private $collection;

    /**
     * @var string
     */
    private $method;

    /**
     * HighOrderCollectionProxy constructor.
     * @param Collection $collection
     * @param string $method
     */
    public function __construct(Collection $collection, string $method)
    {
        $this->collection = $collection;
        $this->method = $method;
    }

    /**
     * @param string $property
     * @return Collection|mixed
     */
    public function __get(string $property)
    {
        return $this->collection->{$this->method}(function($item) use ($property) {
            if ($this->hasProperty($item, $property)) {
                return $item->$property;
            }

            if ($this->isArrayable($item)) {
                return $item[$property];
            }

            if ($this->hasMethod($item, $property)) {
                return $item->$property();
            }

            if (\function_exists($property)) {
                return $property($item);
            }

            $snake = Str::snake($property);

            if (\function_exists($snake)) {
                return $snake($item);
            }
        });
    }

    /**
     * @param string $method
     * @param array $arguments
     * @return Collection|mixed
     */
    public function __call(string $method, array $arguments = [])
    {
        return $this->collection->{$this->method}(function($item) use ($method, $arguments) {
            if ($this->hasMethod($item, $method)) {
                return $item->$method(...$arguments);
            }

            if ($this->hasCallableProperty($item, $method)) {
                return ($item->$method)(...$arguments);
            }

            if ($this->hasCallableKey($item, $method)) {
                return $item[$method](...$arguments);
            }

            if (\function_exists($method)) {
                return $method(...$this->pack($item, $arguments));
            }

            $snake = Str::snake($method);

            if (\function_exists(Str::snake($snake))) {
                return $snake(...$this->pack($item, $arguments));
            }
        });
    }

    /**
     * @param object $context
     * @return bool
     */
    private function isArrayable($context): bool
    {
        return \is_array($context) || $context instanceof \ArrayAccess;
    }

    /**
     * @param object $context
     * @param string $key
     * @return bool
     */
    private function hasCallableKey($context, string $key): bool
    {
        return $this->isArrayable($context) && \is_callable($context[$key] ?? null);
    }

    /**
     * @param object $context
     * @param string $property
     * @return bool
     */
    private function hasProperty($context, string $property): bool
    {
        return \is_object($context) && (
            \property_exists($context, $property) ||
            \method_exists($context, '__get')
        );
    }

    /**
     * @param object $context
     * @param string $property
     * @return bool
     */
    private function hasCallableProperty($context, string $property): bool
    {
        return $this->hasProperty($context, $property) && \is_callable($context->$property);
    }

    /**
     * @param object $context
     * @param string $method
     * @return bool
     */
    private function hasMethod($context, string $method): bool
    {
        return \is_object($context) && (
            \method_exists($context, $method) ||
            \method_exists($context, '__call')
        );
    }

    /**
     * @param object $context
     * @param array $parameters
     * @return array
     */
    private function pack($context, array $parameters): array
    {
        $result = [];

        foreach ($parameters as $parameter) {
            $result[] = $parameter === self::PATTERN ? $context : $parameter;
        }

        return $result;
    }
}