Imanghafoori\Middlewarize\Pipeline

Complexity

Total Complexity

8

Size/Duplication

Total Lines	58
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	through()	0	7	3
A	carry()	0	36	5

<?php

namespace Imanghafoori\Middlewarize;

use InvalidArgumentException;
use Illuminate\Pipeline\Pipeline as CorePipe;

class Pipeline extends CorePipe
{
    /**
     * Set the array of pipes.
     *
     * @param  callable|array|string  $pipes
     * @return \Illuminate\Pipeline\Pipeline
     */
    public function through($pipes)
    {
        $pipes = is_callable($pipes) ? [$pipes] : $pipes;
        $this->pipes = is_array($pipes) ? $pipes : func_get_args();

        return $this;
    }

    /**
     * Get a Closure that represents a slice of the application onion.
     *
     * @return \Closure
     */
    protected function carry()
    {
        return function ($stack, $pipe) {
            return function ($passable) use ($stack, $pipe) {
                if (is_callable($pipe)) {
                    // If the pipe is an instance of a Closure, we will just call it directly but
                    // otherwise we'll resolve the pipes out of the container and call it with
                    // the appropriate method and arguments, returning the results back out.
                    return $pipe($passable, $stack);
                } elseif (is_string($pipe)) {
                    [$name, $parameters] = $this->parsePipeString($pipe);

The variable $name seems only to be defined at a later point. Did you maybe move this code here without moving the variable definition?

The variable $parameters seems only to be defined at a later point. Did you maybe move this code here without moving the variable definition?

                    // If the pipe is a string we will parse the string and resolve the class out
                    // of the dependency injection container. We can then build a callable and
                    // execute the pipe function giving in the parameters that are required.
                    $name = explode('@', $name);

The variable $name seems only to be defined at a later point. Did you maybe move this code here without moving the variable definition?

                    $pipe = $this->getContainer()->make($name[0]);

Consider using a different name than the imported variable $pipe, or did you forget to import by reference?

                    $parameters = array_merge([$passable, $stack], $parameters);

The variable $parameters seems only to be defined at a later point. Did you maybe move this code here without moving the variable definition?

                } elseif (is_object($pipe)) {
                    // If the pipe is already an object we'll just make a callable and pass it to
                    // the pipe as-is. There is no need to do any extra parsing and formatting
                    // since the object we're given was already a fully instantiated object.
                    $parameters = [$passable, $stack];
                } else {
                    throw new InvalidArgumentException(sprintf('A pipe must be an object, a string or a callable. %s given', gettype($pipe)));
                }

                $method = $name[1] ?? $this->method;

                return method_exists($pipe, $method)
                    ? $pipe->{$method}(...$parameters)
                    : $pipe(...$parameters);
            };
        };
    }
}