CarbonFramework\Routing\Conditions\Factory

Complexity

Total Complexity

15

Size/Duplication

Total Lines	106
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

0%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	make()	0	15	4
A	conditionTypeRegistered()	0	12	3
A	makeFromUrl()	0	3	1
A	makeFromClosure()	0	3	1
A	makeFromArrayOfConditions()	0	3	1
B	makeFromArray()	0	27	5

<?php

namespace CarbonFramework\Routing\Conditions;

use CarbonFramework\Framework;
use CarbonFramework\Routing\Conditions\Custom as CustomCondition;
use CarbonFramework\Routing\Conditions\Multiple as MultipleCondition;
use CarbonFramework\Routing\Conditions\Url as UrlCondition;
use Closure;
use Exception;
use ReflectionClass;

/**
 * Check against the current url
 */
class Factory {
	/**
	 * Create a new condition
	 *
	 * @param  string|array|Closure $options
	 * @return ConditionInterface
	 */
	public static function make( $options ) {
		if ( is_string( $options ) ) {
			return static::makeFromUrl( $options );
		}

		if ( is_array( $options ) ) {
			return static::makeFromArray( $options );
		}

		if ( is_a( $options, Closure::class ) ) {
			return static::makeFromClosure( $options );
		}

		throw new InvalidRouteConditionException( 'Invalid condition options supplied.' );
	}

	/**
	 * Check if the passed argument is a registered condition type
	 *
	 * @param  mixed   $condition_type
	 * @return boolean
	 */
	protected static function conditionTypeRegistered( $condition_type ) {
		if ( ! is_string( $condition_type ) ) {
			return false;
		}

		$condition_class = Framework::resolve( 'framework.routing.conditions.' . $condition_type );
		if ( $condition_class === null ) {

This if statement, and the following return statement can be replaced with return !($condition_class === null);.

			return false;
		}

		return true;
	}

	/**
	 * Create a new condition from a url
	 *
	 * @param  string             $url
	 * @return ConditionInterface
	 */
	protected static function makeFromUrl( $url ) {
		return new UrlCondition( $url );
	}

	/**
	 * Create a new condition from a closure
	 *
	 * @param  Closure            $closure
	 * @return ConditionInterface
	 */
	protected static function makeFromClosure( Closure $closure ) {
		return new CustomCondition( $closure );
	}

	/**
	 * Create a new condition from an array of conditions
	 *
	 * @param  array               $options
	 * @return ConditionInterface
	 */
	protected static function makeFromArrayOfConditions( $options ) {
		return new MultipleCondition( $options );
	}

	/**
	 * Create a new condition from an array
	 *
	 * @param  array               $options
	 * @return ConditionInterface
	 */
	protected static function makeFromArray( $options ) {
		if ( count( $options ) === 0 ) {
			throw new Exception( 'No condition type specified.' );
		}

		if ( is_array( $options[0] ) ) {
			return static::makeFromArrayOfConditions( $options );
		}

		$condition_type = $options[0];
		$arguments = array_slice( $options, 1 );

		if ( ! static::conditionTypeRegistered( $condition_type ) ) {
			if ( is_callable( $condition_type ) ) {
				$condition_type = 'custom';
				$arguments = $options;
			} else {
				throw new Exception( 'Unknown condition type specified: ' . $condition_type );
			}
		}

		$condition_class = Framework::resolve( 'framework.routing.conditions.' . $condition_type );

		$reflection = new ReflectionClass( $condition_class );
		$condition = $reflection->newInstanceArgs( $arguments );
		return $condition;
	}
}