JSKOS\Server

Complexity

Total Complexity

19

Size/Duplication

Total Lines	174
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	3
A	setLogger()	0	4	1
A	parseRequest()	0	19	3
B	query()	0	60	8
A	optionsResponse()	0	14	1
A	sendResponse()	0	17	3

<?php declare(strict_types = 1);

namespace JSKOS;

use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Http\Message\ResponseFactory;
use Http\Discovery\MessageFactoryDiscovery;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;

/**
 * A JSKOS Server.
 */
class Server implements \Psr\Log\LoggerAwareInterface
{
    protected $service;
    protected $logger;

    public function __construct(
        Service $service, 
        ResponseFactory $responseFactory=null,
        LoggerInterface $logger=null 
    )
    {
        $this->service = $service;
        $this->responseFactory = $responseFactory ?: MessageFactoryDiscovery::find();

The property responseFactory does not exist. Did you maybe forget to declare it?

        $this->logger = $logger ?: new NullLogger();
    }

    public function setLogger(LoggerInterface $logger)
    {
        $this->logger = $logger;
    }

    protected function parseRequest(RequestInterface $request): array
    {
        $uri = $request->getUri();
        $path = $uri->getPath();
        $query = [];
        parse_str($uri->getQuery(), $query);

        $callback = null;
        if (isset($query['callback'])) {
            if (preg_match('/^[$A-Z_][0-9A-Z_$.]*$/i', $query['callback'])) {
                $callback = $query['callback'];
            }
            unset($query['callback']);
        }

        # TODO: get language parameter from headers

        return [$query, $path, $callback];
    }

    public function query(RequestInterface $request): ResponseInterface
    {    
        $method = $request->getMethod();

        $result = null;
        $callback = null;

        if ($method == 'GET' or $method == 'HEAD') {

Using logical operators such as or instead of || is generally not recommended.

            list ($query, $path, $callback) = $this->parseRequest($request);

            # TODO: detect conflicting parameters?
            # if (isset($params['uri']) and isset($params['search'])) {

80% of this comment could be valid code. Did you maybe forget this after debugging?

            #   $error = new Error(422, 'request_error', 'Conflicting request parameters uri & search');

56% of this comment could be valid code. Did you maybe forget this after debugging?

            # }

            try {
                $result = $this->service->query($query, $path);
            } catch(Error $e) {
                $error = $e;
            }
            # TODO: catch other kinds of errors:
            # } catch (\Exception $e) {

50% of this comment could be valid code. Did you maybe forget this after debugging?

            # $this->logger->error('Service Exception', ['exception' => $e]);

69% of this comment could be valid code. Did you maybe forget this after debugging?

            # $error = new Error(500, 'Internal server error');

54% of this comment could be valid code. Did you maybe forget this after debugging?

        } elseif ($request->getMethod() == 'OPTIONS') {            
            return $this->optionsResponse();
        } else {
            $error = new Error(405, 'Method not allowed');
        }


        if ($result) {
            $code = 200;
            $headers = [
                'Access-Control-Allow-Origin' => '*',
                'Content-Type' => 'application/json; charset=UTF-8',
                'X-Total-Count' => $result->getTotalCount()
            ];
            $body = $result->json();
        } else {
            $code = $error->code;

The variable $error does not seem to be defined for all execution paths leading up to this point.

            $headers = [
                'Access-Control-Allow-Origin' => '*',
                'Content-Type' => 'application/json; charset=UTF-8',
            ];
            $body = $error->json();
        }

        $headers['Content-Length'] = strlen($body);
        if ($method == 'HEAD') {
            $body = '';
        }

        if ($callback) {
            $body = "/**/$callback($body);";
            $headers['Content-Type'] = 'application/javascript; charset=UTF-8';
        }

        return $this->responseFactory->createResponse($code, null, $headers, $body);
    }


    public function optionsResponse()
    {
        $headers = [
            'Access-Control-Allow-Methods' => 'GET, HEAD, OPTIONS',
        ];

        # TODO:
        # if (isset($_SERVER['HTTP_ACCESS_CONTROL_REQUEST_METHOD']) &&

77% of this comment could be valid code. Did you maybe forget this after debugging?

        #    $_SERVER['HTTP_ACCESS_CONTROL_REQUEST_METHOD'] == 'GET') {

59% of this comment could be valid code. Did you maybe forget this after debugging?

        #    $response->headers['Access-Control-Allow-Origin'] = '*';

59% of this comment could be valid code. Did you maybe forget this after debugging?

        #    $response->headers['Acess-Control-Expose-Headers'] = 'Link, X-Total-Count';

59% of this comment could be valid code. Did you maybe forget this after debugging?

        return $this->responseFactory->createResponse(200, null, $headers, '');
    }

    /**
     * TODO: Extract requested languages(s) from request.
    public function extractRequestLanguage($params)
    {
        $language = null;

        # get query modifier: language
        if (isset($params['language'])) {
            $language = $params['language'];
            unset($params['language']);
            # TODO: parse language
        } elseif (isset($_SERVER['HTTP_ACCEPT_LANGUAGE'])) {
            # parse accept-language-header
            preg_match_all(
                '/([a-z]+(?:-[a-z]+)?)\s*(?:;\s*q\s*=\s*(1|0?\.[0-9]+))?/i',
                $_SERVER['HTTP_ACCEPT_LANGUAGE'],
                $match);
            if (count($match[1])) {
                foreach ($match[1] as $i => $l) {
                    if (isset($match[2][$i]) && $match[2][$i] != '') {
                        $langs[strtolower($l)] = (float) $match[2][$i];
                    } else {
                        $langs[strtolower($l)] = 1;
                    }
                }
                arsort($langs, SORT_NUMERIC);
                reset($langs);
                $language = key($langs); # most wanted language
            }
        }
        
        return $language;
    }
*/

	/**
	 * Utility function to emit a Response without additional framework.
	 */
    public static function sendResponse(ResponseInterface $response) 
    {
		$code = $response->getStatusCode();
		$reason = $response->getReasonPhrase();
		header(
			sprintf('HTTP/%s %s %s', $response->getProtocolVersion(), $code, $reason),
			true, $code 
		);

		foreach ($response->getHeaders() as $header => $values) {
			foreach ($values as $value) {
				header("$header: $value", false);
			}
		}

		echo $response->getBody();
	}
}