Obsidian\Routing\RouteGroup

Complexity

Total Complexity

14

Size/Duplication

Total Lines	95
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	4

Test Coverage

Coverage

0%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	3
A	getSatisfiedRoute()	0	9	3
A	satisfied()	0	4	1
A	handle()	0	4	2
A	route()	0	12	3
A	addMiddleware()	0	9	2

<?php

namespace Obsidian\Routing;

use Obsidian\Middleware\HasMiddlewareTrait;
use Obsidian\Request;
use Obsidian\Routing\Conditions\ConditionInterface;
use Obsidian\Routing\Conditions\Url as UrlCondition;
use Closure;
use Exception;

class RouteGroup implements RouteInterface {
	use HasRoutesTrait {
		route as traitRoute;
	}
	use HasMiddlewareTrait {
		addMiddleware as traitAddMiddleware;
	}

	/**
	 * Route target
	 *
	 * @var ConditionInterface
	 */
	protected $target = null;

	/**
	 * Constructor
	 *
	 * @param string|ConditionInterface $target
	 * @param Closure                   $callable
	 */
	public function __construct( $target, Closure $callable ) {
		if ( is_string( $target ) ) {
			$target = new UrlCondition( $target );
		}

		if ( ! is_a( $target, UrlCondition::class ) ) {
			throw new Exception( 'Route groups can only use route strings.' );
		}

		$this->target = $target;

		$callable( $this );
	}

	/**
	 * Return the first child route which is satisfied
	 *
	 * @return RouteInterface|null
	 */
	protected function getSatisfiedRoute( Request $request ) {
		$routes = $this->getRoutes();
		foreach ( $routes as $route ) {
			if ( $route->satisfied( $request ) ) {
				return $route;
			}
		}
		return null;
	}

	/**
	 * {@inheritDoc}
	 */
	public function satisfied( Request $request ) {
		$route = $this->getSatisfiedRoute( $request );
		return $route !== null;
	}

	/**
	 * {@inheritDoc}
	 */
	public function handle( Request $request, $template ) {
		$route = $this->getSatisfiedRoute( $request );
		return $route ? $route->handle( $request, $template ) : null;
	}

	/**
	 * {@inheritDoc}
	 */
	public function route( $methods, $target, $handler ) {
		if ( is_string( $target ) ) {
			$target = new UrlCondition( $target );
		}

		if ( ! is_a( $target, UrlCondition::class ) ) {
			throw new Exception( 'Routes inside route groups can only use route strings.' );
		}

		$target = $this->target->concatenate( $target );

It seems like you code against a concrete implementation and not the interface Obsidian\Routing\Conditions\ConditionInterface as the method concatenate() does only exist in the following implementations of said interface: Obsidian\Routing\Conditions\Url.

		return $this->traitRoute( $methods, $target, $handler );
	}

	/**
	 * {@inheritDoc}
	 */
	public function addMiddleware( $middleware ) {
		$routes = $this->getRoutes();

		foreach ( $routes as $route ) {
			$route->addMiddleware( $middleware );
		}

		return $this->traitAddMiddleware( $middleware );
	}
}