Request::fullUrl() - Code Metrics - Inspection of "Refactor response pattern" - alkemann/h2l - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#25)

by Alexander

created 2017-09-07 14:41 UTC

Request::fullUrl() A

↳ Parent: Request

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	4
nc	1
nop	1
dl	0
loc	6
rs	9.4285
c	0
b	0
f	0

<?php

namespace alkemann\h2l;

use alkemann\h2l\util\Http;

/**
 * Class Request
 *
 * @TODO : $locale = Locale::acceptFromHttp($_SERVER['HTTP_ACCEPT_LANGUAGE']);
 * @package alkemann\h2l
 */
class Request extends Message
{
    protected $parameters = [];
    protected $request = [];
    protected $server = [];
    protected $get = [];
    protected $post = [];
    protected $route = null;
    protected $content_type = '';
    protected $accept_type = Http::CONTENT_HTML;

    /**
     * Get request parameters from url as url params, get queries or post, in that order
     *
     * @param string $name the name of the parameter
     * @return mixed|null the value or null if not set
     */
    public function param(string $name)
    {
        if (isset($this->parameters[$name])) {
            return $this->parameters[$name];
        }
        if (isset($this->get[$name])) {
            return $this->get[$name];
        }
        if (isset($this->post[$name])) {
            return $this->post[$name];
        }
        return null;
    }

    public function fullUrl(?string $path = null): string
    {
        $path = $path ?? $this->url();
        return
            $this->getServerParam('REQUEST_SCHEME') . '://' .
            $this->getServerParam('HTTP_HOST') . $path;
    }

    /**
     * @param array $request
     * @return Request
     */
    public function withRequestParams(array $request): Request
    {
        $new = clone $this;
        $new->url = $request['url'] ?? '/';
        unset($request['url']);
        $new->request = $request;
        return $new;
    }

    /**
     * @return array
     */
    public function getRequestParams(): array
    {
        return $this->request;
    }

    /**
     * @param array $server
     * @return Request
     */
    public function withServerParams(array $server): Request
    {
        $new = clone $this;
        $new->server = $server;
        $new->setContentTypeFromServerParams($server['HTTP_CONTENT_TYPE'] ?? '');
        $new->setAcceptTypeFromServerParams($server['HTTP_ACCEPT'] ?? '');
        $new->method = $server['REQUEST_METHOD'] ?? Http::GET;
        $new->headers = Http::getRequestHeadersFromServerArray($server);
        return $new;
    }

    private function setContentTypeFromServerParams(string $content_type): void
    {
        $known_content_types = [
            Http::CONTENT_JSON,
            Http::CONTENT_XML,
            Http::CONTENT_TEXT_XML,
            Http::CONTENT_FORM
        ];
        foreach ($known_content_types as $t) {
            if (strpos($content_type, $t) !== false) {
                $this->content_type = $t;
                return;
            }
        }
    }

    private function setAcceptTypeFromServerParams(string $accept_type): void
    {
        $known_accept_types = [
            Http::CONTENT_JSON,
            Http::CONTENT_HTML,
            Http::CONTENT_XML,
            Http::CONTENT_TEXT_XML,
        ];
        foreach ($known_accept_types as $t) {
            if (strpos($accept_type, $t) !== false) {
                $this->accept_type = $t;
                return;
            }
        }
    }

    public function acceptType(): string
    {
        return $this->accept_type;
    }

    /**
     * @return array
     */
    public function getServerParams(): array
    {
        return $this->server;
    }

    public function getServerParam(string $name): ?string
    {
        return $this->server[$name] ?? null;
    }

    /**
     * @param array $post
     * @return Request
     */
    public function withPostData(array $post): Request
    {
        $new = clone $this;
        $new->post = $post;
        return $new;
    }

    /**
     * @return array
     */
    public function getPostData(): array
    {
        return $this->post;
    }

    /**
     * @param array $get
     * @return Request
     */
    public function withGetData(array $get): Request
    {
        $new = clone $this;
        $new->get = $get;
        return $new;
    }

    /**
     * @return array
     */
    public function getGetData(): array
    {
        return $this->get;
    }

    /**
     * @return array
     */
    public function query(): array
    {
        return $this->get;
    }

    /**
     * @param array $parameters
     * @return Request
     */
    public function withUrlParams(array $parameters): Request
    {
        $new = clone $this;
        $new->parameters = $parameters;
        return $new;
    }

    /**
     * @return array
     */
    public function getUrlParams(): array
    {
        return $this->parameters;
    }

    /**
     * @param interfaces\Route $route
     * @return Request
     */
    public function withRoute(interfaces\Route $route): Request
    {
        $new = clone $this;
        $new->route = $route;
        $new->parameters = $route->parameters();
        return $new;
    }

    /**
     * @return interfaces\Route|null
     */
    public function route(): ?interfaces\Route
    {
        return $this->route;
    }
}


1			<?php
2
3			namespace alkemann\h2l;
4
5			use alkemann\h2l\util\Http;
6
7			/**
8			* Class Request
9			*
10			* @TODO : $locale = Locale::acceptFromHttp($_SERVER['HTTP_ACCEPT_LANGUAGE']);
11			* @package alkemann\h2l
12			*/
13			class Request extends Message
14			{
15			protected $parameters = [];
16			protected $request = [];
17			protected $server = [];
18			protected $get = [];
19			protected $post = [];
20			protected $route = null;
21			protected $content_type = '';
22			protected $accept_type = Http::CONTENT_HTML;
23
24			/**
25			* Get request parameters from url as url params, get queries or post, in that order
26			*
27			* @param string $name the name of the parameter
28			* @return mixed\|null the value or null if not set
29			*/
30			public function param(string $name)
31			{
32			if (isset($this->parameters[$name])) {
33			return $this->parameters[$name];
34			}
35			if (isset($this->get[$name])) {
36			return $this->get[$name];
37			}
38			if (isset($this->post[$name])) {
39			return $this->post[$name];
40			}
41			return null;
42			}
43
44			public function fullUrl(?string $path = null): string
45			{
46			$path = $path ?? $this->url();
47			return
48			$this->getServerParam('REQUEST_SCHEME') . '://' .
49			$this->getServerParam('HTTP_HOST') . $path;
50			}
51
52			/**
53			* @param array $request
54			* @return Request
55			*/
56			public function withRequestParams(array $request): Request
57			{
58			$new = clone $this;
59			$new->url = $request['url'] ?? '/';
60			unset($request['url']);
61			$new->request = $request;
62			return $new;
63			}
64
65			/**
66			* @return array
67			*/
68			public function getRequestParams(): array
69			{
70			return $this->request;
71			}
72
73			/**
74			* @param array $server
75			* @return Request
76			*/
77			public function withServerParams(array $server): Request
78			{
79			$new = clone $this;
80			$new->server = $server;
81			$new->setContentTypeFromServerParams($server['HTTP_CONTENT_TYPE'] ?? '');
82			$new->setAcceptTypeFromServerParams($server['HTTP_ACCEPT'] ?? '');
83			$new->method = $server['REQUEST_METHOD'] ?? Http::GET;
84			$new->headers = Http::getRequestHeadersFromServerArray($server);
85			return $new;
86			}
87
88			private function setContentTypeFromServerParams(string $content_type): void
89			{
90			$known_content_types = [
91			Http::CONTENT_JSON,
92			Http::CONTENT_XML,
93			Http::CONTENT_TEXT_XML,
94			Http::CONTENT_FORM
95			];
96			foreach ($known_content_types as $t) {
97			if (strpos($content_type, $t) !== false) {
98			$this->content_type = $t;
99			return;
100			}
101			}
102			}
103
104			private function setAcceptTypeFromServerParams(string $accept_type): void
105			{
106			$known_accept_types = [
107			Http::CONTENT_JSON,
108			Http::CONTENT_HTML,
109			Http::CONTENT_XML,
110			Http::CONTENT_TEXT_XML,
111			];
112			foreach ($known_accept_types as $t) {
113			if (strpos($accept_type, $t) !== false) {
114			$this->accept_type = $t;
115			return;
116			}
117			}
118			}
119
120			public function acceptType(): string
121			{
122			return $this->accept_type;
123			}
124
125			/**
126			* @return array
127			*/
128			public function getServerParams(): array
129			{
130			return $this->server;
131			}
132
133			public function getServerParam(string $name): ?string
134			{
135			return $this->server[$name] ?? null;
136			}
137
138			/**
139			* @param array $post
140			* @return Request
141			*/
142			public function withPostData(array $post): Request
143			{
144			$new = clone $this;
145			$new->post = $post;
146			return $new;
147			}
148
149			/**
150			* @return array
151			*/
152			public function getPostData(): array
153			{
154			return $this->post;
155			}
156
157			/**
158			* @param array $get
159			* @return Request
160			*/
161			public function withGetData(array $get): Request
162			{
163			$new = clone $this;
164			$new->get = $get;
165			return $new;
166			}
167
168			/**
169			* @return array
170			*/
171			public function getGetData(): array
172			{
173			return $this->get;
174			}
175
176			/**
177			* @return array
178			*/
179			public function query(): array
180			{
181			return $this->get;
182			}
183
184			/**
185			* @param array $parameters
186			* @return Request
187			*/
188			public function withUrlParams(array $parameters): Request
189			{
190			$new = clone $this;
191			$new->parameters = $parameters;
192			return $new;
193			}
194
195			/**
196			* @return array
197			*/
198			public function getUrlParams(): array
199			{
200			return $this->parameters;
201			}
202
203			/**
204			* @param interfaces\Route $route
205			* @return Request
206			*/
207			public function withRoute(interfaces\Route $route): Request
208			{
209			$new = clone $this;
210			$new->route = $route;
211			$new->parameters = $route->parameters();
212			return $new;
213			}
214
215			/**
216			* @return interfaces\Route\|null
217			*/
218			public function route(): ?interfaces\Route
219			{
220			return $this->route;
221			}
222			}
223

alkemann / h2l

Pull Request — master (#25)

Request::fullUrl() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like