Spatie\CollectionMacros\Helpers\CatchableCollectionProxy

Complexity

Total Complexity

9

Size/Duplication

Total Lines	79
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	__call()	0	6	1
A	catch()	0	21	5
A	exceptionType()	0	10	2

<?php

namespace Spatie\CollectionMacros\Helpers;

use Exception;
use Illuminate\Support\Enumerable;
use ReflectionFunction;

/**
 * @mixin \Illuminate\Collections\Enumerable
 */
class CatchableCollectionProxy
{
    /**
     * The collection being operated on.
     *
     * @var \Illuminate\Collections\Enumerable
     */
    protected $collection;

    /**
     * The collection methods to handle exceptions for.
     *
     * @var array
     */
    protected $calledMethods = [];

    /**
     * Create a new proxy instance.
     *
     * @param  \Illuminate\Collections\Enumerable  $collection
     * @return void

Adding a @return annotation to constructors is generally not recommended as a constructor does not have a meaningful return value.

     */
    public function __construct(Enumerable $collection)
    {
        $this->collection = $collection;
    }

    /**
     * Proxy a method call onto the collection items.
     *
     * @param  string  $method
     * @param  array  $parameters
     * @return $this
     */
    public function __call($method, $parameters)
    {
        $this->calledMethods[] = ['name' => $method, 'parameters' => $parameters];

        return $this;
    }

    /**
     * @param \Closure[] $handlers
     *
     * @return \Illuminate\Collections\Enumerable
     */
    public function catch(...$handlers)
    {
        $originalCollection = $this->collection;

        try {
            foreach ($this->calledMethods as $calledMethod) {
                $this->collection = $this->collection->{$calledMethod['name']}(...$calledMethod['parameters']);
            }
        } catch (Exception $exception) {
            foreach ($handlers as $callable) {
                $type = $this->exceptionType($callable);
                if ($exception instanceof $type) {
                    return $callable($exception, $originalCollection) ?? $originalCollection;
                }
            }

            throw $exception;
        }

        return $this->collection;
    }

    private function exceptionType($callable)
    {
        $reflection = new ReflectionFunction($callable);

        if (empty($reflection->getParameters())) {
            return Exception::class;
        }

        return optional($reflection->getParameters()[0]->getType())->getName() ?? Exception::class;
    }
}