CapMousse\ReactRestify\Server

Complexity

Total Complexity

11

Size/Duplication

Total Lines	160
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes	7
Bugs	1	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	14	3
B	__invoke()	0	24	2
A	group()	0	4	1
A	setAccessControlAllowOrigin()	0	4	1
B	initEvents()	0	24	1
A	on()	0	5	1
A	listen()	0	7	1
A	__call()	0	4	1

<?php

namespace CapMousse\ReactRestify;

use React\Http\Request as HttpRequest;
use React\Http\Response as HttpResponse;

class Server
{
    /**
     * Name of the server
     * @var string
     */
    public $name = "ReactRestify";

    /**
     * Version of the API
     * @var null
     */
    public $version = null;

    /**
     * @var \React\Restify\Router
     */
    private $router;

    /**
     * @var string
     */
    private $allowOrigin = "*";

    /**
     * @param null $name
     * @param null $version
     */
    public function __construct($name = null, $version = null)
    {
        if (null !== $name) {
            $this->name = $name;
        }

        if (null !== $version) {
            $this->version = $version;
        }

        $this->router = new Routing\Router();

It seems like new \CapMousse\ReactRestify\Routing\Router() of type object<CapMousse\ReactRestify\Routing\Router> is incompatible with the declared type object<React\Restify\Router> of property $router.

        $this->initEvents();
    }

    /**
     * Parse request from user
     *
     * @param \React\Http\Request  $HttpRequest

There is no parameter named $HttpRequest. Did you maybe mean $httpRequest?

     * @param \React\Http\Response $HttpResponse

There is no parameter named $HttpResponse. Did you maybe mean $httpResponse?

     */
    public function __invoke(HttpRequest $httpRequest, HttpResponse $httpResponse)
    {
        $start = microtime(true);

        $request = new Http\Request($httpRequest);
        $response = new Http\Response($httpResponse, $this->name, $this->version);

        try {
            $this->router->launch($request, $response, function() use ($request, $response, $start) {
                $end = microtime(true) - $start;

                $response->addHeader("X-Response-Time", $end);
                $response->addHeader("Date", date(DATE_RFC822));
                $response->addHeader("Access-Control-Request-Method", "POST, GET, PUT, DEL");
                $response->addHeader("Access-Control-Allow-Origin", $this->allowOrigin);

                $response->end();
            });
        } catch (\Exception $e) {
            $response->write($e->getMessage());
            $response->setStatus(500);
            $response->end();
        }
    }

    /**
     * Create a new group of route
     * @param String   $prefix   prefix of the routes
     * @param Callable $callback
     *
     * @return \CapMousse\ReactRestify\Routing\Routes
     */
    public function group($prefix, $callback)
    {
        return $this->router->addGroup($prefix, $callback);
    }

    /**
     * The the Access-Control-Allow-Origin header
     *
     * @param string $origin
     */
    public function setAccessControlAllowOrigin($origin)
    {
        $this->allowOrigin = $origin;
    }

    /**
     * Init default event catch
     *
     * @return void
     */
    private function initEvents()
    {
        $this->router->on('NotFound', function($request, $response, $next) {
            $response->write('Not found');
            $response->setStatus(404);

            $next();
        });

        $this->router->on('MethodNotAllowed', function($request, $response, $next) {
            $response->write('Method Not Allowed');
            $response->setStatus(405);

            $next();
        });

        $this->router->on('error', function ($request, $response, $error, $next) {
            $response->write($error);
            $response->write("\n".$request->getContent());
            $response->setStatus(500);

            $next();
        });
    }

    /**
     * Manual router event manager
     * @param String   $event
     * @param Callable $callback
     */
    public function on($event, $callback)
    {
        $this->router->removeAllListeners($event);
        $this->router->on($event, $callback);
    }

    /**
     * Create runner instance
     * @param  Int    $port
     * @param  String $host
     * @return Server
     */
    public function listen($port, $host = "127.0.0.1")
    {
        $runner = new Runner($this);
        $runner->listen($port, $host);

        return $this;
    }

    /**
     * @param string $name      method to call
     * @param array  $arguments
     */
    public function __call($name, $arguments)
    {
        return $this->router->addRoute($name, $arguments[0], $arguments[1]);
    }
}