htmlburger / wpemerge

src/Middleware/HasMiddlewareDefinitionsTrait.php

<?php
/**
 * @package   WPEmerge
 * @author    Atanas Angelov <atanas.angelov.dev@gmail.com>
 * @copyright 2018 Atanas Angelov
 * @license   https://www.gnu.org/licenses/gpl-2.0.html GPL-2.0
 * @link      https://wpemerge.com/
 */

namespace WPEmerge\Middleware;

use WPEmerge\Exceptions\ConfigurationException;

/**
 * Provide middleware definitions.
 */
trait HasMiddlewareDefinitionsTrait {
	/**
	 * Middleware available to the application.
	 *
	 * @var array<string, string>
	 */
	protected $middleware = [];

	/**
	 * Middleware groups.
	 *
	 * @var array<string, array<string>>
	 */
	protected $middleware_groups = [];

	/**
	 * Middleware groups that should have the 'global' group prepended to them.
	 *
	 * @var array<string, string>
	 */
	protected $middleware_groups_with_global = [
		'web',
		'admin',
		'ajax',
	];

	/**
	 * Register middleware.
	 *
	 * @codeCoverageIgnore
	 * @param  array<string, string> $middleware
	 * @return void
	 */
	public function setMiddleware( $middleware ) {
		$this->middleware = $middleware;
	}

	/**
	 * Register middleware groups.
	 *
	 * @codeCoverageIgnore
	 * @param  array<string, array<string>> $middleware_groups
	 * @return void
	 */
	public function setMiddlewareGroups( $middleware_groups ) {
		$this->middleware_groups = $middleware_groups;
	}

	/**
	 * Filter array of middleware into a unique set.
	 *
	 * @param  array<string> $middleware
	 * @return array<string>
	 */
	public function uniqueMiddleware( $middleware ) {
		return array_values( array_unique( $middleware, SORT_REGULAR ) );
	}

	/**
	 * Expand array of middleware into an array of fully qualified class names.
	 *
	 * @param  array<array> $middleware
	 * @return array<array>
	 */
	public function expandMiddleware( $middleware ) {
		$classes = [];

		foreach ( $middleware as $item ) {
			$classes = array_merge(
				$classes,
				$this->expandMiddlewareMolecule( $item )

$item of type array is incompatible with the type string expected by parameter $middleware of WPEmerge\Middleware\HasMiddlewareDefinitionsTrait::expandMiddlewareMolecule().

			);
		}

		return $classes;
	}

	/**
	 * Expand a middleware group into an array of fully qualified class names.
	 *
	 * @param  string        $group
	 * @return array<array>
	 */
	public function expandMiddlewareGroup( $group ) {
		if ( ! isset( $this->middleware_groups[ $group ] ) ) {
			throw new ConfigurationException( 'Unknown middleware group "' . $group . '" used.' );
		}

		$middleware = $this->middleware_groups[ $group ];

		if ( in_array( $group, $this->middleware_groups_with_global, true ) ) {
			$middleware = array_merge( ['global'], $middleware );
		}

		return $this->expandMiddleware( $middleware );

It seems like $middleware can also be of type string[]; however, parameter $middleware of WPEmerge\Middleware\HasMiddlewareDefinitionsTrait::expandMiddleware() does only seem to accept array<mixed,array>, maybe add an additional type check?

	}

	/**
	 * Expand middleware into an array of fully qualified class names and any companion arguments.
	 *
	 * @param  string       $middleware
	 * @return array<array>
	 */
	public function expandMiddlewareMolecule( $middleware ) {
		$pieces = explode( ':', $middleware, 2 );

		if ( count( $pieces ) > 1 ) {
			return [array_merge( [$this->expandMiddlewareAtom( $pieces[0] )], explode( ',', $pieces[1] ) )];
		}

		if ( isset( $this->middleware_groups[ $middleware ] ) ) {
			return $this->expandMiddlewareGroup( $middleware );
		}

		return [[$this->expandMiddlewareAtom( $middleware )]];
	}

	/**
	 * Expand a single middleware a fully qualified class name.
	 *
	 * @param  string $middleware
	 * @return string
	 */
	public function expandMiddlewareAtom( $middleware ) {
		if ( isset( $this->middleware[ $middleware ] ) ) {
			return $this->middleware[ $middleware ];
		}

		if ( class_exists( $middleware ) ) {
			return $middleware;
		}

		throw new ConfigurationException( 'Unknown middleware "' . $middleware . '" used.' );
	}
}