Response::resolveTemplateFromFilesystem() - Code Metrics - Inspection of "improve HasMiddlewareTrait tests" - htmlburger/wpemerge - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 2f1c34...4bc1b6 )

by Atanas

created 2017-11-29 16:29 UTC

Response::resolveTemplateFromFilesystem() A

↳ Parent: Response

Complexity

Conditions	3
Paths	3

Size

Total Lines	8
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	3

Importance

Changes

Metric	Value
cc	3
eloc	5
nc	3
nop	1
dl	0
loc	8
ccs	6
cts	6
cp	1
crap	3
rs	9.4285
c	0
b	0
f	0

<?php

namespace Obsidian;

use Exception;
use GuzzleHttp\Psr7;
use GuzzleHttp\Psr7\Response as Psr7Response;
use Psr\Http\Message\ResponseInterface;

/**
 * A collection of tools for the creation of responses
 */
class Response {
	/**
	 * Create a new response object
	 *
	 * @return ResponseInterface
	 */
	public static function response() {
		return new Psr7Response();
	}

	/**
	 * Send output based on a response object
	 * @credit modified version of slimphp/slim - Slim/App.php
	 *
	 * @codeCoverageIgnore
	 * @param  ResponseInterface $response
	 * @return null
	 */
	public static function respond( ResponseInterface $response ) {
		if ( ! headers_sent() ) {
			static::sendHeaders( $response );
		}
		static::sendBody( $response );
	}

	/**
	 * Send a request's headers to the client
	 *
	 * @codeCoverageIgnore
	 * @param  ResponseInterface $response
	 * @return null
	 */
	protected static function sendHeaders( ResponseInterface $response ) {
		// Status
		header( sprintf(
			'HTTP/%s %s %s',
			$response->getProtocolVersion(),
			$response->getStatusCode(),
			$response->getReasonPhrase()
		) );

		// Headers
		foreach ( $response->getHeaders() as $name => $values ) {
			foreach ( $values as $value ) {
				header( sprintf( '%s: %s', $name, $value ), false );
			}
		}
	}

	/**
	 * Return a response's body stream so it is ready to be read
	 *
	 * @codeCoverageIgnore
	 * @param  ResponseInterface                 $response
	 * @return \Psr\Http\Message\StreamInterface
	 */
	protected static function getBody( ResponseInterface $response ) {
		$body = $response->getBody();
		if ( $body->isSeekable() ) {
			$body->rewind();
		}
		return $body;
	}

	/**
	 * Return a response's body's content length
	 *
	 * @codeCoverageIgnore
	 * @param  ResponseInterface $response
	 * @return integer
	 */
	protected static function getBodyContentLength( ResponseInterface $response ) {
		$content_length = $response->getHeaderLine( 'Content-Length' );

		if ( ! $content_length ) {
			$body = static::getBody( $response );
			$content_length = $body->getSize();
		}

		if ( ! is_numeric( $content_length ) ) {
			$content_length = 0;
		}

		return (integer) $content_length;
	}

	/**
	 * Send a request's body to the client
	 *
	 * @codeCoverageIgnore
	 * @param  ResponseInterface $response
	 * @return null
	 */
	protected static function sendBody( ResponseInterface $response, $chunk_size = 4096 ) {
		$body = static::getBody( $response );
		$content_length = static::getBodyContentLength( $response );

		$content_left = $content_length ? $content_length : -1;
		$amount_to_read = $content_left > -1 ? min( $chunk_size, $content_left ) : $chunk_size;

		while ( ! $body->eof() ) {
			echo $body->read( $amount_to_read );

			if ( $content_left > -1 ) {
				$content_left -= $amount_to_read;
			}

			if ( connection_status() != CONNECTION_NORMAL ) {
				break;
			}
		}
	}

	/**
	 * Return a cloned response with the passed string as the body
	 *
	 * @param  ResponseInterface $response
	 * @param  string            $output
	 * @return ResponseInterface
	 */
	public static function output( ResponseInterface $response, $output ) {
		$response = $response->withBody( Psr7\stream_for( $output ) );
		return $response;
	}

	/**
	 * Resolve a template or a template array to an absolute filepath
	 *
	 * @param  string|string[] $templates
	 * @return string
	 */
	protected static function resolveTemplate( $templates ) {
		$templates = is_array( $templates ) ? $templates : [$templates];
		$template = locate_template( $templates, false );

		// locate_template failed to find the template - test if a valid absolute path was passed
		if ( ! $template ) {
			$template = static::resolveTemplateFromFilesystem( $templates );
		}

		return $template;
	}

	/**
	 * Resolve the first existing absolute template filepath from an array of template filepaths
	 *
	 * @param  string[] $templates
	 * @return string
	 */
	protected static function resolveTemplateFromFilesystem( $templates ) {
		foreach ( $templates as $template ) {
			if ( file_exists( $template ) ) {
				return $template;
			}
		}
		return '';
	}

	/**
	 * Return a cloned response, resolving and rendering a template as the body
	 *
	 * @param  ResponseInterface $response
	 * @param  string|string[]   $templates
	 * @param  array             $context
	 * @return ResponseInterface
	 */
	public static function template( ResponseInterface $response, $templates, $context = array() ) {
		$template = static::resolveTemplate( $templates );

		if ( ! $template ) {
			throw new Exception( 'Could not resolve template.' );
		}

		$engine = Framework::resolve( 'framework.templating.engine' );
		$html = $engine->render( $template, $context );

		$response = $response->withHeader( 'Content-Type', 'text/html' );
		$response = $response->withBody( Psr7\stream_for( $html ) );
		return $response;
	}

	/**
	 * Return a cloned response, json encoding the passed data as the body
	 *
	 * @param  ResponseInterface $response
	 * @param  mixed             $data
	 * @return ResponseInterface
	 */
	public static function json( ResponseInterface $response, $data ) {
		$response = $response->withHeader( 'Content-Type', 'application/json' );
		$response = $response->withBody( Psr7\stream_for( wp_json_encode( $data ) ) );
		return $response;
	}

	/**
	 * Return a cloned response, with location and status headers
	 *
	 * @param  ResponseInterface $response
	 * @param  string            $url
	 * @param  integer           $status
	 * @return ResponseInterface
	 */
	public static function redirect( ResponseInterface $response, $url, $status = 302 ) {
		$response = $response->withStatus( $status );
		$response = $response->withHeader( 'Location', $url );
		return $response;
	}

	/**
	 * Return a cloned response, with location header equal to the current url and status header
	 *
	 * @param  ResponseInterface $response
	 * @param  \Obsidian\Request $request
	 * @param  integer           $status
	 * @return ResponseInterface
	 */
	public static function reload( ResponseInterface $response, $request, $status = 302 ) {
		return static::redirect( $response, $request->getUrl(), 302 );
	}

	/**
	 * Return a cloned response, with status headers and rendering a suitable template as the body
	 *
	 * @param  ResponseInterface $response
	 * @param  integer           $status
	 * @return ResponseInterface
	 */
	public static function error( ResponseInterface $response, $status ) {
		global $wp_query;
		if ( $status === 404 ) {
			$wp_query->set_404();
		}

		$response = $response->withStatus( $status );
		return static::template( $response, array( $status . '.php', 'index.php' ) );
	}
}


1		<?php
2
3		namespace Obsidian;
4
5		use Exception;
6		use GuzzleHttp\Psr7;
7		use GuzzleHttp\Psr7\Response as Psr7Response;
8		use Psr\Http\Message\ResponseInterface;
9
10		/**
11		* A collection of tools for the creation of responses
12		*/
13		class Response {
14		/**
15		* Create a new response object
16		*
17		* @return ResponseInterface
18		*/
19	1	public static function response() {
20	1	return new Psr7Response();
21		}
22
23		/**
24		* Send output based on a response object
25		* @credit modified version of slimphp/slim - Slim/App.php
26		*
27		* @codeCoverageIgnore
28		* @param ResponseInterface $response
29		* @return null
30		*/
31		public static function respond( ResponseInterface $response ) {
32		if ( ! headers_sent() ) {
33		static::sendHeaders( $response );
34		}
35		static::sendBody( $response );
36		}
37
38		/**
39		* Send a request's headers to the client
40		*
41		* @codeCoverageIgnore
42		* @param ResponseInterface $response
43		* @return null
44		*/
45		protected static function sendHeaders( ResponseInterface $response ) {
46		// Status
47		header( sprintf(
48		'HTTP/%s %s %s',
49		$response->getProtocolVersion(),
50		$response->getStatusCode(),
51		$response->getReasonPhrase()
52		) );
53
54		// Headers
55		foreach ( $response->getHeaders() as $name => $values ) {
56		foreach ( $values as $value ) {
57		header( sprintf( '%s: %s', $name, $value ), false );
58		}
59		}
60		}
61
62		/**
63		* Return a response's body stream so it is ready to be read
64		*
65		* @codeCoverageIgnore
66		* @param ResponseInterface $response
67		* @return \Psr\Http\Message\StreamInterface
68		*/
69		protected static function getBody( ResponseInterface $response ) {
70		$body = $response->getBody();
71		if ( $body->isSeekable() ) {
72		$body->rewind();
73		}
74		return $body;
75		}
76
77		/**
78		* Return a response's body's content length
79		*
80		* @codeCoverageIgnore
81		* @param ResponseInterface $response
82		* @return integer
83		*/
84		protected static function getBodyContentLength( ResponseInterface $response ) {
85		$content_length = $response->getHeaderLine( 'Content-Length' );
86
87		if ( ! $content_length ) {
88		$body = static::getBody( $response );
89		$content_length = $body->getSize();
90		}
91
92		if ( ! is_numeric( $content_length ) ) {
93		$content_length = 0;
94		}
95
96		return (integer) $content_length;
97		}
98
99		/**
100		* Send a request's body to the client
101		*
102		* @codeCoverageIgnore
103		* @param ResponseInterface $response
104		* @return null
105		*/
106		protected static function sendBody( ResponseInterface $response, $chunk_size = 4096 ) {
107		$body = static::getBody( $response );
108		$content_length = static::getBodyContentLength( $response );
109
110		$content_left = $content_length ? $content_length : -1;
111		$amount_to_read = $content_left > -1 ? min( $chunk_size, $content_left ) : $chunk_size;
112
113		while ( ! $body->eof() ) {
114		echo $body->read( $amount_to_read );
115
116		if ( $content_left > -1 ) {
117		$content_left -= $amount_to_read;
118		}
119
120		if ( connection_status() != CONNECTION_NORMAL ) {
121		break;
122		}
123		}
124		}
125
126		/**
127		* Return a cloned response with the passed string as the body
128		*
129		* @param ResponseInterface $response
130		* @param string $output
131		* @return ResponseInterface
132		*/
133	1	public static function output( ResponseInterface $response, $output ) {
134	1	$response = $response->withBody( Psr7\stream_for( $output ) );
135	1	return $response;
136		}
137
138		/**
139		* Resolve a template or a template array to an absolute filepath
140		*
141		* @param string\|string[] $templates
142		* @return string
143		*/
144	2	protected static function resolveTemplate( $templates ) {
145	2	$templates = is_array( $templates ) ? $templates : [$templates];
146	2	$template = locate_template( $templates, false );
147
148		// locate_template failed to find the template - test if a valid absolute path was passed
149	2	if ( ! $template ) {
150	2	$template = static::resolveTemplateFromFilesystem( $templates );
151	2	}
152
153	2	return $template;
154		}
155
156		/**
157		* Resolve the first existing absolute template filepath from an array of template filepaths
158		*
159		* @param string[] $templates
160		* @return string
161		*/
162	2	protected static function resolveTemplateFromFilesystem( $templates ) {
163	2	foreach ( $templates as $template ) {
164	2	if ( file_exists( $template ) ) {
165	1	return $template;
166		}
167	1	}
168	1	return '';
169		}
170
171		/**
172		* Return a cloned response, resolving and rendering a template as the body
173		*
174		* @param ResponseInterface $response
175		* @param string\|string[] $templates
176		* @param array $context
177		* @return ResponseInterface
178		*/
179	2	public static function template( ResponseInterface $response, $templates, $context = array() ) {
180	2	$template = static::resolveTemplate( $templates );
181
182	2	if ( ! $template ) {
183	1	throw new Exception( 'Could not resolve template.' );
184		}
185
186	1	$engine = Framework::resolve( 'framework.templating.engine' );
187	1	$html = $engine->render( $template, $context );
188
189	1	$response = $response->withHeader( 'Content-Type', 'text/html' );
190	1	$response = $response->withBody( Psr7\stream_for( $html ) );
191	1	return $response;
192		}
193
194		/**
195		* Return a cloned response, json encoding the passed data as the body
196		*
197		* @param ResponseInterface $response
198		* @param mixed $data
199		* @return ResponseInterface
200		*/
201	1	public static function json( ResponseInterface $response, $data ) {
202	1	$response = $response->withHeader( 'Content-Type', 'application/json' );
203	1	$response = $response->withBody( Psr7\stream_for( wp_json_encode( $data ) ) );
204	1	return $response;
205		}
206
207		/**
208		* Return a cloned response, with location and status headers
209		*
210		* @param ResponseInterface $response
211		* @param string $url
212		* @param integer $status
213		* @return ResponseInterface
214		*/
215	2	public static function redirect( ResponseInterface $response, $url, $status = 302 ) {
216	2	$response = $response->withStatus( $status );
217	2	$response = $response->withHeader( 'Location', $url );
218	2	return $response;
219		}
220
221		/**
222		* Return a cloned response, with location header equal to the current url and status header
223		*
224		* @param ResponseInterface $response
225		* @param \Obsidian\Request $request
226		* @param integer $status
227		* @return ResponseInterface
228		*/
229		public static function reload( ResponseInterface $response, $request, $status = 302 ) {
230		return static::redirect( $response, $request->getUrl(), 302 );
231		}
232
233		/**
234		* Return a cloned response, with status headers and rendering a suitable template as the body
235		*
236		* @param ResponseInterface $response
237		* @param integer $status
238		* @return ResponseInterface
239		*/
240	1	public static function error( ResponseInterface $response, $status ) {
241	1	global $wp_query;
242	1	if ( $status === 404 ) {
243	1	$wp_query->set_404();
244	1	}
245
246	1	$response = $response->withStatus( $status );
247	1	return static::template( $response, array( $status . '.php', 'index.php' ) );
248		}
249		}
250

htmlburger / wpemerge

Push — master ( 2f1c34...4bc1b6 )

Response::resolveTemplateFromFilesystem() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like