PinkCrab\Route\Registration\WP_Rest_Registrar

Complexity

Total Complexity

10

Size/Duplication

Total Lines	111
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	compose_permission_callback()	0	14	3
A	parse_options()	0	19	3
A	create_callback()	0	4	1
A	parse_args()	0	8	1
A	is_valid_method()	0	8	1
A	map_to_wp_rest()	0	6	1

<?php

declare(strict_types=1);

/**
 * Registers routes through WP API from Route mooels.
 *
 * @package PinkCrab\Route\Route
 * @author Glynn Quelch glynn@pinkcrab.co.uk
 * @since 0.0.1
 */

namespace PinkCrab\Route\Registration;

use PinkCrab\Route\Route\Route;
use PinkCrab\Route\Route_Exception;
use PinkCrab\WP_Rest_Schema\Argument\Argument;
use PinkCrab\WP_Rest_Schema\Parser\Argument_Parser;
use function PinkCrab\FunctionConstructors\Comparisons\all;

class WP_Rest_Registrar {

	/**
	 * The register wp rest callback.
	 *
	 * @param \PinkCrab\Route\Route\Route $route
	 * @return callable
	 */
	public function create_callback( Route $route ): callable {
		return function() use ( $route ): void {
			$model = $this->map_to_wp_rest( $route );
			register_rest_route( $model->namespace, $model->route, $model->args );
		};
	}

	/**
	 * Maps a wp rest model from Route.
	 *
	 * @param \PinkCrab\Route\Route\Route $route
	 * @return WP_Rest_Route
	 */
	public function map_to_wp_rest( Route $route ): WP_Rest_Route {
		$wp_rest            = new WP_Rest_Route();
		$wp_rest->namespace = $route->get_namespace();
		$wp_rest->route     = $route->get_route();
		$wp_rest->args      = $this->parse_options( $route );
		return $wp_rest;
	}

	/**
	 * Parsed the args array used to register.
	 *
	 * @param Route $route
	 * @return array<mixed>
	 * @throws Route_Exception
	 */
	protected function parse_options( Route $route ): array {

		// If we have no callback defined for route, throw.
		if ( is_null( $route->get_callback() ) ) {

The condition is_null($route->get_callback()) is always false.

			throw Route_Exception::callback_not_defined( $route );
		}

		// If we have an invlaid method, throw
		if ( ! $this->is_valid_method( $route->get_method() ) ) {
			throw Route_Exception::invalid_http_method( $route );
		}

		$options                        = array();
		$options['methods']             = $route->get_method();
		$options['callback']            = $route->get_callback();
		$options['permission_callback'] = $this->compose_permission_callback( $route );
		$options['args']                = $this->parse_args( $route );

		return $options;
	}

	/**
	 * Parsed the args array of options.
	 *
	 * @param Route $route
	 * @return array<mixed>
	 */
	protected function parse_args( Route $route ): array {
		return array_reduce(
			$route->get_arguments(),
			function( array $args, Argument $argument ) {
				$args[ $argument->get_key() ] = Argument_Parser::as_single( $argument );
				return $args;
			},
			array()
		);
	}

	/**
	 * Checks if a defined HTTP method is valid.
	 *
	 * @param string $method
	 * @return boolean
	 */
	protected function is_valid_method( string $method ): bool {
		return in_array(
			$method,
			apply_filters(
				'pinkcrab/route/accepted_http_methods', // phpcs:ignore WordPress.NamingConventions.ValidHookName
				array( Route::DELETE, Route::POST, Route::PUT, Route::PATCH, Route::GET )
			),
			true
		);
	}

	/**
	 * Compose the permission callback function for the route.
	 *
	 * @param Route $route
	 * @return callable
	 */
	protected function compose_permission_callback( Route $route ): callable {
		$callbacks = $route->get_authentication();

		// If we have no callback defined, use return true.
		if ( count( $callbacks ) === 0 ) {
			return '__return_true';
		}

		// If we only have 1, return as is.
		if ( count( $callbacks ) === 1 ) {
			return reset( $callbacks );
		}

		return all( ...$callbacks );
	}


}