SimplePie\HandlerStack

Complexity

Total Complexity

22

Size/Duplication

Total Lines	259
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	1
A	append()	0	15	1
A	appendClosure()	0	9	1
A	prepend()	0	15	1
A	prependClosure()	0	9	1
B	invoke()	0	29	3
A	debugStack()	0	17	2
C	validateMiddleware()	0	22	8
A	logRegistration()	0	13	2
A	exceptionMessage()	0	13	2

<?php
/**
 * Copyright (c) 2017 Ryan Parman <http://ryanparman.com>.
 * Copyright (c) 2017 Contributors.
 *
 * http://opensource.org/licenses/Apache2.0
 */

declare(strict_types=1);

namespace SimplePie;

use DOMXPath;
use Psr\Log\LoggerInterface;
use SimplePie\Enum\FeedType;
use SimplePie\Exception\MiddlewareException;
use SimplePie\Middleware\Html\HtmlInterface;
use SimplePie\Middleware\Json\JsonInterface;
use SimplePie\Middleware\Xml\XmlInterface;
use Skyzyx\UtilityPack\Types;
use stdClass;

/**
 * `SimplePie\HandlerStack` is a middleware stack system which is modeled after
 * [Guzzle's middleware handler stack system](http://docs.guzzlephp.org/en/latest/handlers-and-middleware.html),
 * but is designed specifically for SimplePie's use-cases.
 *
 * Its primary job is to (a) allow the registration and priority of middleware,
 * and (b) provide the interface for SimplePie NG to trigger middleware.
 */
class HandlerStack implements HandlerStackInterface
{
    /**
     * A PSR-3 logger.
     *
     * @var LoggerInterface
     */
    protected $logger;

    /**
     * The middleware stack, grouped by feed type.
     *
     * @var string
     */
    protected $stack;

    /**
     * Constructs a new instance of this class.
     */
    public function __construct()
    {
        $this->logger = Configuration::getLogger();

        $this->stack = [

It seems like array('html' => array(), 'json' => array(), 'xml' => array()) of type array<string,array,{"html":"array","json":"array","xml":"array"}> is incompatible with the declared type string of property $stack.

            'html' => [],
            'json' => [],
            'xml'  => [],
        ];
    }

    /**
     * {@inheritdoc}
     *
     * @codingStandardsIgnoreStart
     */
    public function append(
        callable $middleware,
        ?string $name = null,
        ?string $overrideType = null
    ): HandlerStackInterface {
        // @codingStandardsIgnoreEnd

        $this->validateMiddleware($middleware, $name, $overrideType, function (&$arr) use ($middleware, $name): void {
            $arr[] = [$middleware, $name];
        });

        $this->logRegistration($middleware, $name, $overrideType);

        return $this;
    }

    /**
     * {@inheritdoc}
     *
     * @codingStandardsIgnoreStart
     */
    public function appendClosure(
        string $overrideType,
        callable $middleware,
        ?string $name = null
    ): HandlerStackInterface {
        // @codingStandardsIgnoreEnd

        return $this->append($middleware, $name, $overrideType);
    }

    /**
     * {@inheritdoc}
     *
     * @codingStandardsIgnoreStart
     */
    public function prepend(
        callable $middleware,
        ?string $name = null,
        ?string $overrideType = null
    ): HandlerStackInterface {
        // @codingStandardsIgnoreEnd

        $this->validateMiddleware($middleware, $name, $overrideType, function (&$arr) use ($middleware, $name): void {
            \array_unshift($arr, [$middleware, $name]);
        });

        $this->logRegistration($middleware, $name, $overrideType);

        return $this;
    }

    /**
     * {@inheritdoc}
     *
     * @codingStandardsIgnoreStart
     */
    public function prependClosure(
        string $overrideType,
        callable $middleware,
        ?string $name = null
    ): HandlerStackInterface {
        // @codingStandardsIgnoreEnd

        return $this->prepend($middleware, $name, $overrideType);
    }

    /**
     * {@inheritdoc}
     *
     * @codingStandardsIgnoreStart
     */
    public function invoke(
        string $feedType,
        stdClass $feedRoot,
        ?string $namespaceAlias,
        DOMXPath $xpath
    ): void {
        // @codingStandardsIgnoreEnd

        if (isset($this->stack[$feedType])) {
            foreach ($this->stack[$feedType] as $tuple) {

The expression $this->stack[$feedType] of type string is not traversable.

                $middleware = $tuple[0];
                $middleware($feedRoot, $namespaceAlias, $xpath);
            }
        } else {
            $allowedTypes = FeedType::introspectKeys();
            \array_shift($allowedTypes);

            throw new MiddlewareException(\sprintf(
                'Could not determine which handler stack to invoke. Stack `%s` was requested. [Allowed: %s]',
                $feedType,
                \implode(', ', \array_map(
                    function ($type) {
                        return \sprintf('FeedType::%s', $type);
                    },
                    $allowedTypes
                ))
            ));
        }
    }

    /**
     * [debugStack description].
     *
     * @return [type] [description]

The doc-type [type] could not be parsed: Unknown type name "" at position 0. [(view supported doc-types)

     */
    public function debugStack(): array
    {
        $fn = function ($mw) {
            return \sprintf(
                '[<%s: resource %s>, %s]',
                Types::getClassOrType($mw[0]),
                \md5(\spl_object_hash($mw[0])),
                isset($mw[1]) ? \sprintf('"%s"', $mw[1]) : 'null'
            );
        };

        return [
            'html' => \array_map($fn, $this->stack['html']),
            'json' => \array_map($fn, $this->stack['json']),
            'xml'  => \array_map($fn, $this->stack['xml']),
        ];
    }

    /**
     * Validates the middleware and applies it to the right stack.
     *
     * @param callable    $middleware   The middleware to add to the stack.
     * @param string|null $name         A name for the middleware. Can be used with `pushBefore()` and `pushAfter()`.
     * @param string|null $overrideType Override our best guess for which stack to apply the middleware to. By default
     *                                  the appropriate stack will be determined by which
     *                                  `SimplePie\Middleware\*\*Interface` the middleware extends from. If the
     *                                  middleware is a closure, this parameter is required. If the appropriate stack
     *                                  cannot be determined, a `SimplePie\Exception\MiddlewareException` exception
     *                                  will be thrown.
     * @param callable    $fn           A callable which receives the stack by-reference as a parameter, and chooses
     *                                  how to add the middleware to that stack.
     *
     * @throws MiddlewareException
     *
     * @codingStandardsIgnoreStart
     */
    protected function validateMiddleware(
        callable $middleware,
        ?string $name = null,
        ?string $overrideType = null,
        callable $fn
    ): void {
        // @codingStandardsIgnoreEnd

        if ($overrideType === FeedType::ALL) {
            $fn($this->stack['html']);
            $fn($this->stack['json']);
            $fn($this->stack['xml']);
        } elseif ($overrideType === FeedType::JSON || $middleware instanceof JsonInterface) {
            $fn($this->stack['json']);
        } elseif ($overrideType === FeedType::XML || $middleware instanceof XmlInterface) {
            $fn($this->stack['xml']);
        } elseif ($overrideType === FeedType::HTML || $middleware instanceof HtmlInterface) {
            $fn($this->stack['html']);
        } else {
            throw new MiddlewareException($this->exceptionMessage($middleware, $name, $overrideType));
        }
    }

    /**
     * Log that the registration of the middleware occurred.
     *
     * @param callable    $middleware   The middleware to add to the stack.
     * @param string|null $name         A name for the middleware. Can be used with `pushBefore()` and `pushAfter()`.
     * @param string|null $overrideType Override our best guess for which stack to apply the middleware to. By default
     *                                  the appropriate stack will be determined by which
     *                                  `SimplePie\Middleware\*\*Interface` the middleware extends from. If the
     *                                  middleware is a closure, this parameter is required. If the appropriate stack
     *                                  cannot be determined, a `SimplePie\Exception\MiddlewareException` exception
     *                                  will be thrown.
     *
     * @codingStandardsIgnoreStart
     */
    protected function logRegistration(
        callable $middleware,
        ?string $name = null,
        ?string $overrideType = null

The parameter $overrideType is not used and could be removed.

    ): void {
        // @codingStandardsIgnoreEnd

        $this->logger->info(\sprintf(
            'Registered `%s` as middleware%s.',
            Types::getClassOrType($middleware),
            (null !== $name ? \sprintf(' with the name `%s`', $name) : '')
        ));
    }

    /**
     * Generate the most appropriate error message based on the parameters that were passed.
     *
     * @param callable    $middleware   The middleware to add to the stack.
     * @param string|null $name         A name for the middleware. Can be used with `pushBefore()` and `pushAfter()`.
     * @param string|null $overrideType Override our best guess for which stack to apply the middleware to. By default
     *                                  the appropriate stack will be determined by which
     *                                  `SimplePie\Middleware\*\*Interface` the middleware extends from. If the
     *                                  middleware is a closure, this parameter is required. If the appropriate stack
     *                                  cannot be determined, a `SimplePie\Exception\MiddlewareException` exception
     *                                  will be thrown.
     *
     * @return string
     *
     * @codingStandardsIgnoreStart
     */
    protected function exceptionMessage(
        callable $middleware,
        ?string $name = null,
        ?string $overrideType = null

The parameter $overrideType is not used and could be removed.

    ): string {
        // @codingStandardsIgnoreEnd

        return \sprintf(
            'The middleware `%s`%s could not be assigned to a feed type.',
            Types::getClassOrType($middleware),
            (null !== $name ? \sprintf(' with the name `%s`', $name) : '')
        );
    }
}