9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 | EEE;
20 | $res->send($html);
21 | });
22 |
23 | $router->post('/', function ($req, $res) {
24 | $res->send(''.print_r($_POST, true));
25 | });
26 |
27 | $router->run();
--------------------------------------------------------------------------------
/examples/06-params/.htaccess:
--------------------------------------------------------------------------------
1 |
2 | RewriteEngine On
3 |
4 | RewriteCond %{REQUEST_METHOD} ^(TRACE|TRACK)
5 | RewriteRule .* - [F]
6 |
7 | RewriteCond %{ENV:REDIRECT_STATUS} 200
8 | RewriteRule .* - [L]
9 |
10 | RewriteCond %{REQUEST_FILENAME} !-f
11 | RewriteCond %{REQUEST_FILENAME} !-d
12 | RewriteRule ^(.*)$ index.php?_path_=$1 [QSA,L]
13 |
--------------------------------------------------------------------------------
/examples/06-params/index.php:
--------------------------------------------------------------------------------
1 | param('username', '[a-zA-Z\d]{1,32}');
7 | $app->param('wildcard', '.*');
8 |
9 | $app->get('/', function ($req, $res) {
10 | $link = 'user/riverside/pictures/123456/Test-98_7/ea416ed0759d46a8de58f63a59077499';
11 | $res->send('Pattern: user/:username/pictures/:id/:wildcard/:hash
Link: '.$link.'
');
12 | });
13 |
14 | $app->get('user/:username/pictures/:id/:wildcard/:hash', function ($req, $res) {
15 | $res->send('« Back'.print_r($req->params, true));
16 | });
17 |
18 | $app->run();
--------------------------------------------------------------------------------
/examples/07-restful/.htaccess:
--------------------------------------------------------------------------------
1 |
2 | RewriteEngine On
3 |
4 | RewriteCond %{REQUEST_METHOD} ^(TRACE|TRACK)
5 | RewriteRule .* - [F]
6 |
7 | RewriteCond %{ENV:REDIRECT_STATUS} 200
8 | RewriteRule .* - [L]
9 |
10 | RewriteCond %{REQUEST_FILENAME} !-f
11 | RewriteCond %{REQUEST_FILENAME} !-d
12 | RewriteRule ^(.*)$ index.php?_path_=$1 [QSA,L]
13 |
14 |
--------------------------------------------------------------------------------
/examples/07-restful/index.php:
--------------------------------------------------------------------------------
1 | method == 'HEAD')
8 | {
9 | $res->end();
10 | }
11 | $res->json([
12 | 'method' => $req->method,
13 | 'content-type' => $req->get("content-type"),
14 | 'params' => $req->params,
15 | 'body' => $req->body,
16 | ]);
17 | };
18 |
19 | $app->get('/', function($req, $res) {
20 | $html = <<
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 | Examples
10 |
19 |
20 |
21 |
--------------------------------------------------------------------------------
/phpunit.xml.dist:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | ./tests/
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
--------------------------------------------------------------------------------
/src/Application.php:
--------------------------------------------------------------------------------
1 | 'views',
23 | 'template' => 'layouts/default'
24 | );
25 |
26 | /**
27 | * @var array
28 | */
29 | protected $locals = array();
30 |
31 | /**
32 | * @var Request
33 | */
34 | protected $request;
35 |
36 | /**
37 | * @var Response
38 | */
39 | protected $response;
40 |
41 | /**
42 | * @var array
43 | */
44 | protected $patterns = array(
45 | ':id' => '(\d+)',
46 | ':hash' => '([a-f\d+]{32})'
47 | );
48 |
49 | /**
50 | * Application constructor.
51 | */
52 | public function __construct()
53 | {
54 | $this->request = new Request($this);
55 | $this->response = new Response($this);
56 | }
57 |
58 | /**
59 | * Return an instance of response object.
60 | *
61 | * @return Response
62 | */
63 | public function getResponse(): Response
64 | {
65 | return $this->response;
66 | }
67 |
68 | /**
69 | * Return an instance of request object.
70 | *
71 | * @return Request
72 | */
73 | public function getRequest(): Request
74 | {
75 | return $this->request;
76 | }
77 |
78 | /**
79 | * Sets the Boolean setting name to false
80 | *
81 | * @param string $name
82 | * @return Application
83 | */
84 | public function disable(string $name): Application
85 | {
86 | return $this->set($name, false);
87 | }
88 |
89 | /**
90 | * Returns true if the Boolean setting name is disabled (false)
91 | *
92 | * @param string $name
93 | * @return bool
94 | */
95 | public function disabled(string $name): bool
96 | {
97 | return !$this->set($name);
98 | }
99 |
100 | /**
101 | * Sets the Boolean setting name to true
102 | *
103 | * @param string $name
104 | * @return Application
105 | */
106 | public function enable(string $name): Application
107 | {
108 | return $this->set($name, true);
109 | }
110 |
111 | /**
112 | * Returns true if the setting name is enabled (true)
113 | *
114 | * @param string $name
115 | * @return bool
116 | */
117 | public function enabled(string $name): bool
118 | {
119 | return (bool) $this->set($name);
120 | }
121 |
122 | /**
123 | * Attempt to create an instance of Router, if such not already exists
124 | *
125 | * @return Application
126 | */
127 | protected function lazyrouter(): Application
128 | {
129 | if (!$this->router)
130 | {
131 | $this->router = new Router($this);
132 | }
133 |
134 | return $this;
135 | }
136 |
137 | /**
138 | * Get/set local variables to use within the application.
139 | *
140 | * @param string|null $name
141 | * @param null $value
142 | * @return Application|array|mixed|null
143 | */
144 | public function local(string $name = null, $value = null)
145 | {
146 | $num = func_num_args();
147 |
148 | if ($num == 0)
149 | {
150 | // getter
151 | return $this->locals;
152 | }
153 |
154 | if ($num == 1) {
155 | // getter
156 | return array_key_exists($name, $this->locals)
157 | ? $this->locals[$name]
158 | : null;
159 | }
160 |
161 | // setter
162 | $this->locals[$name] = $value;
163 |
164 | return $this;
165 | }
166 |
167 | /**
168 | * Add custom parameters to use in a route path.
169 | *
170 | * @param string $name
171 | * @param string|null $regex
172 | * @return Application
173 | */
174 | public function param(string $name, string $regex = null): Application
175 | {
176 | $this->patterns[":$name"] = $regex ? "($regex)" : '(.*)';
177 |
178 | return $this;
179 | }
180 |
181 | /**
182 | * Returns the rendered HTML of a view. It accepts an optional parameter that is an array containing local variables
183 | * for the view. It is like $res->render(), except it cannot send the rendered view to the client on its own.
184 | *
185 | * @param string $view
186 | * @param array|null $locals
187 | */
188 | public function render(string $view, array $locals=null): void
189 | {
190 | if ($locals)
191 | {
192 | extract($locals);
193 | }
194 | $layout = sprintf("%s/%s.php", $this->set("views"), $view);
195 | $_template = sprintf("%s/%s.php", $this->set("views"), $this->set("template"));
196 | if (is_file($_template))
197 | {
198 | include $_template;
199 | } else {
200 | include $layout;
201 | }
202 | }
203 |
204 | /**
205 | * Returns an instance of a single route, which you can then use to handle HTTP verbs with optional middleware.
206 | * Use $app->route() to avoid duplicate route names (and thus typo errors).
207 | *
208 | * @param string $path
209 | * @return Route
210 | */
211 | public function route(string $path): Route
212 | {
213 | $this->lazyrouter();
214 |
215 | $route = $this->router->route($path);
216 |
217 | return $route;
218 | }
219 |
220 | /**
221 | * Run the application.
222 | */
223 | public function run(): void
224 | {
225 | if (!$this->router)
226 | {
227 | return;
228 | }
229 |
230 | foreach ($this->router->getRoutes() as $route)
231 | {
232 | $match1 = in_array($route->getMethod(), array('all', 'use', strtolower($this->request->method)));
233 | if (!$match1)
234 | {
235 | continue;
236 | }
237 |
238 | $use = $route->getMethod() == "use";
239 | $found = 0;
240 |
241 | $pattern = sprintf("#^%s$#", str_replace(array_keys($this->patterns), array_values($this->patterns), $route->getPath()));
242 | if (!$use)
243 | {
244 | $match2 = null;
245 | if (!preg_match($pattern, $this->request->path, $match2))
246 | {
247 | continue;
248 | } else {
249 | $found = 1;
250 | //array_shift($match2);
251 | $this->request->route = $route->getPath();
252 | $this->setParams();
253 | }
254 | } else {
255 | if (!($route->getPath() == '*' || preg_match($pattern, $this->request->path)))
256 | {
257 | continue;
258 | }
259 | }
260 |
261 | foreach ($route->getCallback() as $callback)
262 | {
263 | $found = 1;
264 | if (is_array($callback))
265 | {
266 | foreach ($callback as $arg)
267 | {
268 | $route->dispatch($arg, $use);
269 | }
270 | } else {
271 | $route->dispatch($callback, $use);
272 | }
273 | }
274 |
275 | if ($found && !$use)
276 | {
277 | break;
278 | }
279 | }
280 | }
281 |
282 | /**
283 | * Set params
284 | *
285 | * @return Application
286 | */
287 | protected function setParams(): Application
288 | {
289 | $route_parts = explode('/', $this->request->route);
290 | $path_parts = explode('/', $this->request->path);
291 | foreach ($route_parts as $key => $value)
292 | {
293 | if (strpos($value, ':') === 0)
294 | {
295 | $this->request->params[substr($value, 1)] = $path_parts[$key];
296 | }
297 | }
298 |
299 | return $this;
300 | }
301 |
302 | /**
303 | * Assigns setting name to value.
304 | *
305 | * @param string $name
306 | * @param mixed|null $value
307 | * @return Application|mixed|null
308 | */
309 | public function set(string $name, $value = null)
310 | {
311 | if (func_num_args() == 1)
312 | {
313 | // getter
314 | return array_key_exists($name, $this->settings)
315 | ? $this->settings[$name]
316 | : null;
317 | }
318 |
319 | // setter
320 | $this->settings[$name] = $value;
321 |
322 | return $this;
323 | }
324 |
325 | /**
326 | * Mounts the specified middleware function at the specified path: the middleware function is executed when
327 | * the base of the requested path matches path.
328 | *
329 | * @return Application
330 | */
331 | public function use(): Application
332 | {
333 | $num_args = func_num_args();
334 | if (!$num_args)
335 | {
336 | return $this;
337 | }
338 |
339 | $args = func_get_args();
340 | switch ($num_args)
341 | {
342 | case 1:
343 | $path = '*';
344 | $offset = 0;
345 | break;
346 | default:
347 | $path = $args[0];
348 | $offset = 1;
349 | }
350 |
351 | $arguments = array_slice($args, $offset);
352 |
353 | $this->lazyrouter();
354 |
355 | $route = $this->router->route($path);
356 |
357 | call_user_func_array(array($route, 'use'), $arguments);
358 |
359 | return $this;
360 | }
361 |
362 | /**
363 | * Routes HTTP (verb) requests to the specified path with the specified callback function.
364 | *
365 | * @param string $name Accepts: delete, get, head, options, patch, post, put, all
366 | * @param array $arguments
367 | * @return Application
368 | */
369 | public function __call(string $name, array $arguments): Application
370 | {
371 | $methods = array_merge(Route::METHODS, array('all'));
372 | if (!in_array($name, $methods))
373 | {
374 | trigger_error("The '$name' method is not defined", E_USER_WARNING);
375 | }
376 |
377 | $this->lazyrouter();
378 |
379 | $route = $this->router->route($arguments[0]);
380 | $route->setMethod($name);
381 | $route->setCallback(array_slice($arguments, 1));
382 |
383 | //call_user_func_array(array($route, $name), array_slice($arguments, 1));
384 |
385 | return $this;
386 | }
387 | }
--------------------------------------------------------------------------------
/src/Request.php:
--------------------------------------------------------------------------------
1 | app = $app;
154 | $this->body = &$_POST;
155 | $this->cookies = &$_COOKIE;
156 | $this->files = &$_FILES;
157 | $this->hostname = $_SERVER['HTTP_HOST'];
158 | $this->ip = $_SERVER['REMOTE_ADDR'];
159 | $this->method = strtoupper($_SERVER['REQUEST_METHOD']);
160 | $this->originalUrl = $_SERVER['REQUEST_URI'];
161 | $this->path = $path;
162 | $this->port = (int) $_SERVER['SERVER_PORT'];
163 | $this->protocol = $_SERVER['SERVER_PROTOCOL'];
164 | $this->query = &$_GET;
165 | //$this->route = '';
166 | $this->scheme = self::getRequestScheme();
167 | $this->secure = $this->scheme == 'https';
168 | $this->session = &$_SESSION;
169 | $this->xhr = isset($_SERVER['HTTP_X_REQUESTED_WITH']) && $_SERVER['HTTP_X_REQUESTED_WITH'] == 'XMLHttpRequest';
170 |
171 | // Make data payloads available in $this->body for other HTTP verbs.
172 | if (
173 | $this->method !== 'POST'
174 | && $this->get('content-type') == 'application/x-www-form-urlencoded'
175 | ) {
176 | parse_str(file_get_contents('php://input'), $_POST);
177 | }
178 |
179 | // Add support for multipart/form-data parsing for other HTTP verbs in PHP >=8.4.
180 | if (
181 | $this->method !== 'POST'
182 | && $this->get('content-type') == 'multipart/form-data'
183 | && function_exists('request_parse_body')
184 | ) {
185 | [$_POST, $_FILES] = call_user_func('request_parse_body');
186 | }
187 | }
188 |
189 | /**
190 | * Checks if the specified content type is acceptable, based on the request's Accept HTTP header field
191 | *
192 | * @param string $mimeType
193 | * @return bool
194 | */
195 | public function accept(string $mimeType): bool
196 | {
197 | $header = $this->get('Accept');
198 | if (!$header)
199 | {
200 | return false;
201 | }
202 |
203 | $mimeType = strtolower($mimeType);
204 | $arr = explode(',', $header);
205 | $arr = array_map('trim', $arr);
206 | $arr = array_map('strtolower', $arr);
207 | foreach ($arr as $item)
208 | {
209 | if (strpos($item, ';q=') !== false)
210 | {
211 | list($item,) = explode(';q=', $item);
212 | }
213 |
214 | // Accept: text/html
215 | // Value: text/html
216 | if ($item == $mimeType)
217 | {
218 | return true;
219 | }
220 |
221 | // Accept: */*
222 | if ($item == '*/*')
223 | {
224 | return true;
225 | }
226 |
227 | // Accept: text/*
228 | // Value: text/html
229 | if (strpos($item, '/*') !== false
230 | && substr($item, 0, strpos($item, '/')) == substr($mimeType, 0, strpos($mimeType, '/')))
231 | {
232 | return true;
233 | }
234 | }
235 |
236 | return false;
237 | }
238 |
239 | /**
240 | * Checks if the specified encoding is acceptable, based on the request's Accept-Encoding HTTP header field
241 | *
242 | * @param string $encoding
243 | * @return bool
244 | */
245 | public function acceptEncoding(string $encoding): bool
246 | {
247 | $header = $this->get('Accept-Encoding');
248 | if (!$header)
249 | {
250 | return false;
251 | }
252 |
253 | $encoding = strtolower($encoding);
254 | $arr = explode(',', $header);
255 | $arr = array_map('trim', $arr);
256 | $arr = array_map('strtolower', $arr);
257 | foreach ($arr as $item)
258 | {
259 | $weight = 1;
260 | if (strpos($item, ';q=') !== false)
261 | {
262 | list($item, $weight) = explode(';q=', $item);
263 | }
264 |
265 | if ($weight == 0 && in_array($item, array('*', 'identity')))
266 | {
267 | return false;
268 | }
269 |
270 | if ($item == '*')
271 | {
272 | return true;
273 | }
274 |
275 | if ($item == $encoding)
276 | {
277 | return true;
278 | }
279 | }
280 |
281 | return false;
282 | }
283 |
284 | /**
285 | * Checks if the specified language is acceptable, based on the request's Accept-Language HTTP header field
286 | *
287 | * @param string $language
288 | * @return bool
289 | */
290 | public function acceptLanguage(string $language): bool
291 | {
292 | $header = $this->get('Accept-Language');
293 | if (!$header)
294 | {
295 | return false;
296 | }
297 |
298 | $language = strtolower($language);
299 | $arr = explode(',', $header);
300 | $arr = array_map('trim', $arr);
301 | $arr = array_map('strtolower', $arr);
302 | foreach ($arr as $item)
303 | {
304 | if (strpos($item, ';q=') !== false)
305 | {
306 | list($item,) = explode(';q=', $item);
307 | }
308 |
309 | // Accept: en-US
310 | // Value: en-US
311 | if ($item == $language)
312 | {
313 | return true;
314 | }
315 |
316 | // Accept: *
317 | if ($item == '*')
318 | {
319 | return true;
320 | }
321 | }
322 |
323 | return false;
324 | }
325 |
326 | /**
327 | * Returns the specified HTTP request header field (case-insensitive match).
328 | *
329 | * @param string $name
330 | * @return string|null
331 | */
332 | public static function get(string $name): ?string
333 | {
334 | $name = strtolower($name);
335 |
336 | $headers = function_exists('apache_request_headers')
337 | ? apache_request_headers()
338 | : self::getRequestHeaders();
339 |
340 | foreach ($headers as $header => $value)
341 | {
342 | $header = strtolower($header);
343 | if ($header == $name)
344 | {
345 | return $value;
346 | }
347 | }
348 |
349 | return null;
350 | }
351 |
352 | /**
353 | * Alias of get()
354 | *
355 | * @param string $name
356 | * @return string|null
357 | */
358 | public static function header(string $name): ?string
359 | {
360 | return self::get($name);
361 | }
362 |
363 | /**
364 | * Returns the matching content type if the incoming request's "Content-Type" HTTP header field matches the MIME
365 | * type specified by the type parameter.
366 | *
367 | * @param string $type
368 | * @return bool
369 | */
370 | public static function is(string $type): bool
371 | {
372 | $contentType = self::get("content-type");
373 | list($contentType,) = explode(";", $contentType);
374 |
375 | return $contentType == $type;
376 | }
377 |
378 | /**
379 | * Returns the request scheme, i.e. 'http' or 'https'.
380 | *
381 | * @return string
382 | */
383 | protected static function getRequestScheme() : string
384 | {
385 | // Modern servers will have the HTTPS header set to 'on' or '1'.
386 | if (
387 | isset($_SERVER['HTTPS'])
388 | && (
389 | strtolower($_SERVER['HTTPS']) == 'on'
390 | || $_SERVER['HTTPS'] == 1
391 | )
392 | ) {
393 | return 'https';
394 | }
395 | // Some reverse proxies and load balencers will have the
396 | // HTTP_X_FORWARDED_PROTO header set to 'https'.
397 | else if (
398 | isset($_SERVER['HTTP_X_FORWARDED_PROTO'])
399 | && strtolower($_SERVER['HTTP_X_FORWARDED_PROTO']) == 'https'
400 | ) {
401 |
402 | return 'https';
403 | }
404 | // Other reverse proxies and load balencers will have the
405 | // HTTP_FRONT_END_HTTPS headers set to 'on' or '1'.
406 | else if (
407 | isset($_SERVER['HTTP_FRONT_END_HTTPS'])
408 | && (
409 | strtolower($_SERVER['HTTP_FRONT_END_HTTPS']) == 'on'
410 | || $_SERVER['HTTP_FRONT_END_HTTPS'] == 1
411 | )
412 | ) {
413 | return 'https';
414 | }
415 | // Apache server may have the REQUEST_SCHEME header available.
416 | else if (
417 | isset($_SERVER['REQUEST_SCHEME'])
418 | && strtolower($_SERVER['REQUEST_SCHEME']) == 'https'
419 | ) {
420 | return 'https';
421 | }
422 | // If all else fails, try the standard SSL server port '443'.
423 | else if (
424 | isset($_SERVER['SERVER_PORT'])
425 | && intval($_SERVER['SERVER_PORT']) === 443
426 | ) {
427 | return 'https';
428 | }
429 | return 'http';
430 | }
431 |
432 | /**
433 | * Fetch all HTTP request headers
434 | *
435 | * @return array
436 | */
437 | protected static function getRequestHeaders(): array
438 | {
439 | $arh = array();
440 | foreach (headers_list() as $header)
441 | {
442 | $header = explode(":", $header);
443 | $arh[array_shift($header)] = trim(implode(":", $header));
444 | }
445 |
446 | return $arh;
447 | }
448 | }
449 |
--------------------------------------------------------------------------------
/src/Response.php:
--------------------------------------------------------------------------------
1 | 'Continue',
45 | 101 => 'Switching Protocols',
46 | 102 => 'Processing', // RFC 2518, obsoleted by RFC 4918
47 | 103 => 'Early Hints',
48 | 200 => 'OK',
49 | 201 => 'Created',
50 | 202 => 'Accepted',
51 | 203 => 'Non-Authoritative Information',
52 | 204 => 'No Content',
53 | 205 => 'Reset Content',
54 | 206 => 'Partial Content',
55 | 207 => 'Multi-Status', // RFC 4918
56 | 208 => 'Already Reported',
57 | 226 => 'IM Used',
58 | 300 => 'Multiple Choices', // RFC 7231
59 | 301 => 'Moved Permanently',
60 | 302 => 'Found',
61 | 303 => 'See Other',
62 | 304 => 'Not Modified',
63 | 305 => 'Use Proxy',
64 | 307 => 'Temporary Redirect',
65 | 308 => 'Permanent Redirect', // RFC 7238
66 | 400 => 'Bad Request',
67 | 401 => 'Unauthorized',
68 | 402 => 'Payment Required',
69 | 403 => 'Forbidden',
70 | 404 => 'Not Found',
71 | 405 => 'Method Not Allowed',
72 | 406 => 'Not Acceptable',
73 | 407 => 'Proxy Authentication Required',
74 | 408 => 'Request Timeout',
75 | 409 => 'Conflict',
76 | 410 => 'Gone',
77 | 411 => 'Length Required',
78 | 412 => 'Precondition Failed',
79 | 413 => 'Payload Too Large',
80 | 414 => 'URI Too Long',
81 | 415 => 'Unsupported Media Type',
82 | 416 => 'Range Not Satisfiable',
83 | 417 => 'Expectation Failed',
84 | 418 => 'I\'m a Teapot', // RFC 7168
85 | 421 => 'Misdirected Request',
86 | 422 => 'Unprocessable Entity', // RFC 4918
87 | 423 => 'Locked', // RFC 4918
88 | 424 => 'Failed Dependency', // RFC 4918
89 | 425 => 'Unordered Collection', // RFC 4918
90 | 426 => 'Upgrade Required', // RFC 2817
91 | 428 => 'Precondition Required', // RFC 6585
92 | 429 => 'Too Many Requests', // RFC 6585
93 | 431 => 'Request Header Fields Too Large', // RFC 6585
94 | 451 => 'Unavailable For Legal Reasons',
95 | 500 => 'Internal Server Error',
96 | 501 => 'Not Implemented',
97 | 502 => 'Bad Gateway',
98 | 503 => 'Service Unavailable',
99 | 504 => 'Gateway Timeout',
100 | 505 => 'HTTP Version Not Supported',
101 | 506 => 'Variant Also Negotiates', // RFC 2295
102 | 507 => 'Insufficient Storage', // RFC 4918
103 | 508 => 'Loop Detected',
104 | 509 => 'Bandwidth Limit Exceeded',
105 | 510 => 'Not Extended', // RFC 2774
106 | 511 => 'Network Authentication Required' // RFC 6585
107 | );
108 |
109 | /**
110 | * Response constructor
111 | *
112 | * @param Application $app
113 | */
114 | public function __construct(Application $app)
115 | {
116 | $this->app = $app;
117 | $this->headersSent = headers_sent() ? 1 : 0;
118 | }
119 |
120 | /**
121 | * Appends the specified value to the HTTP response header field. If the header is not already set, it creates
122 | * the header with the specified value. The value parameter can be a string or an array.
123 | *
124 | * @param string $field
125 | * @param $value
126 | * @return Response
127 | */
128 | public function append(string $field, $value): Response
129 | {
130 | $prev = $this->get($field);
131 |
132 | if ($prev) {
133 | if (is_array($prev)) {
134 | $value = array_merge($prev, array($value));
135 | } elseif (is_array($value)) {
136 | array_unshift($value, $prev);
137 | } else {
138 | $value = array($prev, $value);
139 | }
140 | }
141 |
142 | return $this->set($field, $value);
143 | }
144 |
145 | /**
146 | * Sets the HTTP response Content-Disposition header field to "attachment"
147 | *
148 | * @param string|null $filename
149 | * @return Response
150 | */
151 | public function attachment(string $filename=null): Response
152 | {
153 | $value = $filename
154 | ? 'attachment; filename="' . basename($filename) . '"'
155 | : 'attachment';
156 |
157 | $this->set('Content-Disposition', $value);
158 |
159 | if ($filename)
160 | {
161 | $ext = pathinfo($filename, PATHINFO_EXTENSION);
162 | $this->type($ext, true);
163 | }
164 |
165 | return $this;
166 | }
167 |
168 | /**
169 | * Clears the cookie specified by name.
170 | *
171 | * @param string $name
172 | * @param array $options
173 | * @return Response
174 | */
175 | public function clearCookie(string $name, array $options=array()): Response
176 | {
177 | $options = array_merge(array(
178 | 'expire' => time() - 3600,
179 | 'path' => '/'
180 | ), $options);
181 |
182 | return $this->cookie($name, "", $options);
183 | }
184 |
185 | /**
186 | * Alias of type()
187 | *
188 | * @param string $type
189 | * @param bool $fallback
190 | * @return Response
191 | */
192 | public function contentType(string $type, bool $fallback=false): Response
193 | {
194 | return $this->type($type, $fallback);
195 | }
196 |
197 | /**
198 | * Sets cookie name to value. The value parameter may be a string or array converted to JSON.
199 | *
200 | * @param string $name
201 | * @param string $value
202 | * @param array $options
203 | * @return Response
204 | */
205 | public function cookie(string $name, string $value, array $options=array()): Response
206 | {
207 | $expire = isset($options['expire']) ? $options['expire'] : 0;
208 | $path = isset($options['path']) ? $options['path'] : "";
209 | $domain = isset($options['domain']) ? $options['domain'] : "";
210 | $secure = isset($options['secure']) ? $options['secure'] : false;
211 | $httpOnly = isset($options['httpOnly']) ? $options['httpOnly'] : false;
212 | if (isset($options['sameSite']))
213 | {
214 | if (is_string($options['sameSite']) && in_array(strtolower($options['sameSite']), array("lax", "strict"))) {
215 | $sameSite = strtolower($options['sameSite']);
216 | } elseif (is_bool($options['sameSite'])) {
217 | if (!$options['sameSite']) {
218 | $sameSite = "lax";
219 | } elseif ($options['sameSite']) {
220 | $sameSite = "strict";
221 | }
222 | }
223 | if (isset($sameSite)) {
224 | $path .= "; samesite=" . $sameSite;
225 | }
226 | }
227 |
228 | setcookie($name, $value, $expire, $path, $domain, $secure, $httpOnly);
229 |
230 | return $this;
231 | }
232 |
233 | /**
234 | * Transfers the file at path as an "attachment". Typically, browsers will prompt the user for download.
235 | *
236 | * @param string $path
237 | * @param string|null $filename
238 | */
239 | public function download(string $path, string $filename=null)
240 | {
241 | $name = $filename ? $filename : basename($path);
242 |
243 | $this
244 | ->set('Pragma', 'public')
245 | ->set('Expires', 0)
246 | ->set('Cache-Control', 'must-revalidate, post-check=0, pre-check=0')
247 | ->set('Cache-Control', 'private')
248 | ->set('Content-Transfer-Encoding', 'binary');
249 |
250 | $this->attachment($name);
251 |
252 | $length = @filesize($path);
253 | if ($length > 0)
254 | {
255 | $this->set('Content-Length', $length);
256 | }
257 |
258 | $this->sendHeaders();
259 |
260 | $chunkSize = 1024 * 1024;
261 | $handle = fopen($path, 'rb');
262 | while (!feof($handle))
263 | {
264 | $buffer = fread($handle, $chunkSize);
265 | echo $buffer;
266 | ob_flush();
267 | flush();
268 | }
269 | fclose($handle);
270 | }
271 |
272 | /**
273 | * Ends the response process. Use to quickly end the response without any data.
274 | *
275 | * @param string|null $data
276 | */
277 | public function end(string $data = null): void
278 | {
279 | if ($data)
280 | {
281 | echo $data;
282 | }
283 | exit;
284 | }
285 |
286 | /**
287 | * Returns the HTTP response header specified by field. The match is case-insensitive.
288 | *
289 | * @param string $field
290 | * @return string|null
291 | */
292 | public function get(string $field): ?string
293 | {
294 | $field = strtolower($field);
295 | foreach (headers_list() as $header) {
296 | list ($name, $value) = explode(":", $header, 2);
297 | if (strtolower($name) == $field) {
298 | return trim($value);
299 | }
300 | }
301 |
302 | return null;
303 | }
304 |
305 | /**
306 | * Return an array with response headers.
307 | *
308 | * @return array
309 | */
310 | public function getHeaders(): array
311 | {
312 | return $this->headers;
313 | }
314 |
315 | /**
316 | * Alias of set()
317 | *
318 | * @param string $field
319 | * @param $value
320 | * @return Response
321 | */
322 | public function header(string $field, $value): Response
323 | {
324 | return $this->set($field, $value);
325 | }
326 |
327 | /**
328 | * Sends a JSON response. This method sends a response (with the correct content-type) that is the parameter
329 | * converted to a JSON string using json_encode().
330 | *
331 | * @param mixed $body
332 | * @param int $flags
333 | * @return Response
334 | */
335 | public function json($body, int $flags = 0): Response
336 | {
337 | $body = json_encode($body, $flags);
338 |
339 | if ($this->get("Content-Type") != "application/json") {
340 | $this->type("json");
341 | }
342 |
343 | return $this->send($body);
344 | }
345 |
346 | /**
347 | * Sets the response Location HTTP header to the specified path parameter.
348 | *
349 | * @param string $path
350 | * @return Response
351 | */
352 | public function location(string $path): Response
353 | {
354 | return $this->set("Location", $path);
355 | }
356 |
357 | /**
358 | * Detect mime type
359 | *
360 | * @param string $value
361 | * @return string
362 | */
363 | protected static function mimeLookup(string $value)
364 | {
365 | $value = strtolower($value);
366 |
367 | switch ($value) {
368 | case "html":
369 | $mimeType = "text/html";
370 | break;
371 | case "js":
372 | case "javascript":
373 | $mimeType = "application/javascript";
374 | break;
375 | case "json":
376 | $mimeType = "application/json";
377 | break;
378 | case "css":
379 | $mimeType = "text/css";
380 | break;
381 | case "text":
382 | $mimeType = "text/plain";
383 | break;
384 | case "png":
385 | case "apng":
386 | case "gif":
387 | case "webp":
388 | case "avif":
389 | $mimeType = "image/$value";
390 | break;
391 | case "jpg":
392 | case "jpeg":
393 | $mimeType = "image/jpeg";
394 | break;
395 | case "svg":
396 | $mimeType = "image/svg+xml";
397 | break;
398 | case "pdf":
399 | $mimeType = "application/pdf";
400 | break;
401 | default:
402 | $mimeType = "";
403 | }
404 |
405 | return $mimeType;
406 | }
407 |
408 | /**
409 | * Redirects to the URL derived from the specified path, with specified status, a positive integer that
410 | * corresponds to an HTTP status code.
411 | *
412 | * @param string $path
413 | * @param int $status
414 | */
415 | public function redirect(string $path, int $status = 302): void
416 | {
417 | $this->location($path);
418 |
419 | $this->sendHeaders();
420 | $this->status($status);
421 | $this->end();
422 | }
423 |
424 | /**
425 | * Renders a view and sends the rendered HTML string to the client.
426 | *
427 | * @param string $view
428 | * @param array $locals
429 | */
430 | public function render(string $view, array $locals = array()): void
431 | {
432 | $this->sendHeaders();
433 | $this->status(200);
434 | $this->app->render($view, $locals);
435 | }
436 |
437 | /**
438 | * Sends the HTTP response.
439 | *
440 | * @param mixed $body
441 | * @return Response
442 | */
443 | public function send($body): Response
444 | {
445 | $this->sendHeaders();
446 |
447 | if ($body) {
448 | switch (true) {
449 | case is_string($body):
450 | if (!$this->get('Content-Type')) {
451 | $this->type('html');
452 | }
453 | break;
454 | case is_array($body):
455 | case is_object($body):
456 | case is_numeric($body):
457 | case is_bool($body):
458 | if (!is_null($body)) {
459 | return $this->json($body);
460 | }
461 | break;
462 | }
463 | }
464 |
465 | $this->end($body);
466 |
467 | return $this;
468 | }
469 |
470 | /**
471 | * Send a raw HTTP header
472 | *
473 | * @param string $header
474 | * @param bool $replace
475 | * @param int $statusCode
476 | * @return Response
477 | */
478 | protected function sendHeader(string $header, bool $replace=true, int $statusCode=0): Response
479 | {
480 | if ($statusCode)
481 | {
482 | header($header, $replace, $statusCode);
483 | } else {
484 | header($header, $replace);
485 | }
486 |
487 | return $this;
488 | }
489 |
490 | /**
491 | * @param string $name
492 | * @param string|bool $value
493 | * @return Response
494 | */
495 | protected function proceedHeader(string $name, $value): Response
496 | {
497 | if (is_string($value) && strlen($value) > 0)
498 | {
499 | $this->sendHeader("$name: $value");
500 | } elseif ($value === false) {
501 | $this->removeHeader($name);
502 | }
503 |
504 | return $this;
505 | }
506 |
507 | /**
508 | * Remove previously set headers
509 | *
510 | * @param string $name
511 | * @return Response
512 | */
513 | protected function removeHeader(string $name): Response
514 | {
515 | header_remove($name);
516 |
517 | return $this;
518 | }
519 |
520 | /**
521 | * @return Response
522 | */
523 | protected function sendHeaders(): Response
524 | {
525 | foreach ($this->headers as $name => $value)
526 | {
527 | if (is_array($value))
528 | {
529 | foreach ($value as $val)
530 | {
531 | $this->proceedHeader($name, $val);
532 | }
533 | } else {
534 | $this->proceedHeader($name, $value);
535 | }
536 | }
537 |
538 | return $this;
539 | }
540 |
541 | /**
542 | * Sets the response HTTP status code to statusCode and send its string representation as the response body.
543 | *
544 | * @param int $code
545 | * @return Response
546 | */
547 | public function sendStatus(int $code): Response
548 | {
549 | return $this->type("text")->status($code)->send($this->statusMessage);
550 | }
551 |
552 | /**
553 | * Sets the response's HTTP header field to value. To set multiple fields at once, pass an array as the parameter.
554 | *
555 | * @param array|string $field
556 | * @param mixed|null $value
557 | * @return Response
558 | */
559 | public function set($field, $value=null): Response
560 | {
561 | if (is_array($field)) {
562 | foreach ($field as $key => $val) {
563 | $this->headers[$key] = $val;
564 | }
565 | } else {
566 | $this->headers[$field] = $value;
567 | }
568 |
569 | return $this;
570 | }
571 |
572 | /**
573 | * Sets the HTTP status for the response.
574 | *
575 | * @param int $code
576 | * @return Response
577 | */
578 | public function status(int $code): Response
579 | {
580 | $this->statusCode = $code;
581 |
582 | $this->statusMessage = isset(self::STATUS_CODES[$code]) ? self::STATUS_CODES[$code] : "$code";
583 |
584 | $this->sendHeader("HTTP/1.1 $this->statusCode $this->statusMessage");
585 |
586 | return $this;
587 | }
588 |
589 | /**
590 | * Sets the Content-Type HTTP header to the MIME type as determined by mimeLookup() for the specified type.
591 | *
592 | * @param string $value
593 | * @param bool $fallback
594 | * @return Response
595 | */
596 | public function type(string $value, bool $fallback=false): Response
597 | {
598 | $contentType = self::mimeLookup($value);
599 | if ($contentType)
600 | {
601 | $this->set("Content-Type", $contentType);
602 | } elseif ($fallback) {
603 | $this->set("Content-Type", "application/octet-stream");
604 | }
605 |
606 | return $this;
607 | }
608 |
609 | /**
610 | * Adds the field to the Vary response header, if it is not there already.
611 | *
612 | * @param string $value
613 | * @return Response
614 | */
615 | public function vary(string $value): Response
616 | {
617 | return $this->set("Vary", $value);
618 | }
619 | }
--------------------------------------------------------------------------------
/src/Route.php:
--------------------------------------------------------------------------------
1 | setPath($path);
56 | }
57 |
58 | /**
59 | * Gets a callback
60 | *
61 | * @return array|callable|string
62 | */
63 | public function getCallback()
64 | {
65 | return $this->callback;
66 | }
67 |
68 | /**
69 | * Sets a callback
70 | *
71 | * @param array|string|callable $callback
72 | * @return Route
73 | */
74 | public function setCallback($callback): Route
75 | {
76 | $this->callback = $callback;
77 |
78 | return $this;
79 | }
80 |
81 | /**
82 | * Gets a path
83 | *
84 | * @return string
85 | */
86 | public function getPath(): string
87 | {
88 | return $this->path;
89 | }
90 |
91 | /**
92 | * Sets a path
93 | *
94 | * @param string $path
95 | * @return Route
96 | */
97 | public function setPath(string $path): Route
98 | {
99 | $this->path = $path;
100 |
101 | return $this;
102 | }
103 |
104 | /**
105 | * Gets a method
106 | *
107 | * @return string
108 | */
109 | public function getMethod(): string
110 | {
111 | return $this->method;
112 | }
113 |
114 | /**
115 | * Sets a method
116 | *
117 | * @param string $method
118 | * @return Route
119 | */
120 | public function setMethod(string $method): Route
121 | {
122 | $this->method = $method;
123 |
124 | return $this;
125 | }
126 |
127 | /**
128 | * Gets a name
129 | *
130 | * @return string
131 | */
132 | public function getName(): string
133 | {
134 | return $this->name;
135 | }
136 |
137 | /**
138 | * Sets a name
139 | *
140 | * @param string $name
141 | * @return Route
142 | */
143 | public function setName(string $name): Route
144 | {
145 | $this->name = $name;
146 |
147 | return $this;
148 | }
149 |
150 | /**
151 | * Gets an application instance
152 | *
153 | * @return Application
154 | */
155 | public function getApplication(): Application
156 | {
157 | return $this->app;
158 | }
159 |
160 | /**
161 | * Sets an application
162 | *
163 | * @param Application $app
164 | * @return Route
165 | */
166 | public function setApplication(Application $app): Route
167 | {
168 | $this->app = $app;
169 |
170 | return $this;
171 | }
172 |
173 | /**
174 | * @param string $name Accepts: delete, get, head, options, patch, post, put, all, use
175 | * @param array $arguments
176 | * @return Route
177 | */
178 | public function __call(string $name, array $arguments): Route
179 | {
180 | $methods = array_merge(self::METHODS, array('all', 'use'));
181 | if (!in_array($name, $methods))
182 | {
183 | trigger_error("The '$name' method is not defined", E_USER_WARNING);
184 | }
185 |
186 | $this->setMethod($name);
187 | $this->setCallback($arguments);
188 |
189 | return $this;
190 | }
191 |
192 | /**
193 | * @param callable|string $argument
194 | * @param bool $use
195 | * @return Route
196 | */
197 | public function dispatch($argument, bool $use = false): Route
198 | {
199 | if (is_callable($argument))
200 | {
201 | $argument($this->app->getRequest(), $this->app->getResponse());
202 |
203 | } elseif (is_string($argument)) {
204 |
205 | list($className, $method) = explode("@", $argument);
206 |
207 | try {
208 | $reflectionMethod = new \ReflectionMethod($className, $method);
209 | if ($use)
210 | {
211 | echo $reflectionMethod->invoke(new $className, $this->app->getRequest(), $this->app->getResponse(), function () {
212 | //echo '';
213 | //print_r($this->app->getResponse()->app->router);
214 | });
215 | } else {
216 | echo $reflectionMethod->invoke(new $className, $this->app->getRequest(), $this->app->getResponse());
217 | }
218 | } catch (\ReflectionException $e) {
219 | printf("%s in %s on line %s", $e->getMessage(), $e->getFile(), $e->getLine());
220 | } catch (\Exception $e) {
221 | printf("%s in %s on line %s", $e->getMessage(), $e->getFile(), $e->getLine());
222 | }
223 | }
224 |
225 | return $this;
226 | }
227 | }
--------------------------------------------------------------------------------
/src/Router.php:
--------------------------------------------------------------------------------
1 | app = $app !== null && $app instanceof Application
31 | ? $app
32 | : new Application();
33 | }
34 |
35 | /**
36 | * @return Route[]
37 | */
38 | public function getRoutes(): array
39 | {
40 | return $this->routes;
41 | }
42 |
43 | /**
44 | * Add custom parameters to use in a route path.
45 | *
46 | * @param string $name
47 | * @param string|null $regex
48 | * @return Router
49 | */
50 | public function param(string $name, string $regex = null): Router
51 | {
52 | $this->app->param($name, $regex);
53 |
54 | return $this;
55 | }
56 |
57 | /**
58 | * Returns an instance of a single route which you can then use to handle HTTP verbs with optional middleware.
59 | * Use $router->route() to avoid duplicate route naming and thus typing errors.
60 | *
61 | * @param string $path
62 | * @return Route
63 | */
64 | public function route(string $path): Route
65 | {
66 | $route = new Route($path);
67 | $route->setApplication($this->app);
68 |
69 | $this->routes[] = $route;
70 |
71 | return $route;
72 | }
73 |
74 | /**
75 | * Run the application
76 | */
77 | public function run(): void
78 | {
79 | $this->app->router = $this;
80 | $this->app->run();
81 | }
82 |
83 | /**
84 | * Routes HTTP (verb) requests to the specified path with the specified callback function.
85 | *
86 | * @param string $name Accepts: delete, get, head, options, patch, post, put, all
87 | * @param array $arguments
88 | * @return Router
89 | */
90 | public function __call(string $name, array $arguments): Router
91 | {
92 | $methods = array_merge(Route::METHODS, array('all'));
93 | if (!in_array($name, $methods))
94 | {
95 | trigger_error("The '$name' method is not defined", E_USER_WARNING);
96 | }
97 |
98 | $route = $this->route($arguments[0]);
99 | $route->setMethod($name);
100 | $route->setCallback(array_slice($arguments, 1));
101 |
102 | //call_user_func_array(array($route, $name), array_slice($arguments, 1));
103 |
104 | return $this;
105 | }
106 | }
--------------------------------------------------------------------------------
/src/autoload.php:
--------------------------------------------------------------------------------
1 | assertClassHasAttribute($attribute, Application::class);
22 | }
23 | }
24 | }
--------------------------------------------------------------------------------
/tests/RequestTest.php:
--------------------------------------------------------------------------------
1 | assertClassHasAttribute($attribute, Request::class);
34 | }
35 | }
36 | }
--------------------------------------------------------------------------------
/tests/ResponseTest.php:
--------------------------------------------------------------------------------
1 | assertClassHasAttribute($attribute, Response::class);
23 | }
24 | }
25 | }
--------------------------------------------------------------------------------
/tests/RouteTest.php:
--------------------------------------------------------------------------------
1 | assertClassHasAttribute($attribute, Route::class);
23 | }
24 | }
25 |
26 | public function testPath()
27 | {
28 | $route = new Route('/');
29 |
30 | $route->setPath('/profile');
31 | $this->assertSame('/profile', $route->getPath());
32 | }
33 |
34 | public function testMethod()
35 | {
36 | $route = new Route('/');
37 |
38 | $route->setMethod('POST');
39 | $this->assertSame('POST', $route->getMethod());
40 | }
41 |
42 | public function testApplication()
43 | {
44 | $route = new Route('/');
45 |
46 | $app = new Application();
47 | $route->setApplication($app);
48 | $this->assertSame($app, $route->getApplication());
49 | }
50 |
51 | public function testName()
52 | {
53 | $route = new Route('/');
54 |
55 | $route->setName('test');
56 | $this->assertSame('test', $route->getName());
57 | }
58 |
59 | public function testCallback()
60 | {
61 | $route = new Route('/');
62 |
63 | $route->setCallback('test');
64 | $this->assertSame('test', $route->getCallback());
65 | }
66 |
67 | public function testDispatch()
68 | {
69 | $route = new Route('/');
70 | $route->setApplication(new Application());
71 |
72 | $fn = function($req, $res) {
73 | echo 'test';
74 | };
75 |
76 | ob_start();
77 | $this->assertInstanceOf(Route::class, $route->dispatch($fn));
78 | $content = ob_get_contents();
79 | ob_end_clean();
80 | $this->assertSame('test', $content);
81 | }
82 | }
--------------------------------------------------------------------------------
/tests/RouterTest.php:
--------------------------------------------------------------------------------
1 | assertClassHasAttribute($attribute, Router::class);
20 | }
21 | }
22 |
23 | public function testRoute()
24 | {
25 | $router = new Router();
26 | $route = $router->route('/');
27 |
28 | $this->assertInstanceOf(Route::class, $route);
29 | }
30 | }
--------------------------------------------------------------------------------