JWT - Code Metrics - Inspection of "Refactored" - Spomky-Labs/jose - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 668fd8...cdc0a6 )

by Florent

created 2015-12-09 21:45 UTC

JWT B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	361
Duplicated Lines	0 %

Coupling/Cohesion

Components	4
Dependencies	0

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	361
wmc	47
lcom	4
cbo	0
rs	8.439

32 Methods

Rating	Name	Size	Complexity
A	getEncodedProtectedHeaders()	4	1
A	getInput()	4	1
A	getEncodedPayload()	4	1
A	getProtectedHeaders()	4	1
A	getUnprotectedHeaders()	4	1
A	getPayload()	4	1
A	withInput()	7	1
A	withEncodedProtectedHeaders()	7	1
A	withEncodedPayload()	7	1
A	withProtectedHeaders()	7	1
A	withUnprotectedHeaders()	7	1
A	withProtectedHeader()	7	1
A	withUnprotectedHeader()	7	1
A	withPayload()	7	1
A	getProtectedHeader()	7	2
A	hasProtectedHeader()	4	1
A	withoutProtectedHeader()	10	2
A	getUnprotectedHeader()	7	2
A	hasUnprotectedHeader()	4	1
A	withoutUnprotectedHeader()	10	2
A	getHeaders()	4	1
A	getHeader()	9	3
A	hasHeader()	4	2
A	getHeaderOrClaim()	9	3
A	hasHeaderOrClaim()	4	2
A	getClaim()	7	2
A	getClaims()	7	2
A	hasClaim()	4	2
A	hasClaims()	4	1
A	withClaim()	10	2
A	withoutClaim()	10	2
A	withClaims()	7	1

How to fix Complexity

<?php

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2014-2015 Spomky-Labs
 *
 * This software may be modified and distributed under the terms
 * of the MIT license.  See the LICENSE file for details.
 */

namespace Jose\Object;

/**
 * Class JWT.
 */
class JWT implements JWTInterface
{
    /**
     * @var string
     */
    private $encoded_protected_header = '';

    /**
     * @var string
     */
    private $input = null;

    /**
     * @var string
     */
    private $encoded_payload = '';

    /**
     * @var array
     */
    private $protected_headers = [];

    /**
     * @var array
     */
    private $unprotected_headers = [];

    /**
     * @var null
     */
    private $payload = null;

    /**
     * {@inheritdoc}
     */
    public function getEncodedProtectedHeaders()
    {
        return $this->encoded_protected_header;
    }

    /**
     * {@inheritdoc}
     */
    public function getInput()
    {
        return $this->input;
    }

    /**
     * {@inheritdoc}
     */
    public function getEncodedPayload()
    {
        return $this->encoded_payload;
    }

    /**
     * {@inheritdoc}
     */
    public function getProtectedHeaders()
    {
        return $this->protected_headers;
    }

    /**
     * {@inheritdoc}
     */
    public function getUnprotectedHeaders()
    {
        return $this->unprotected_headers;
    }

    /**
     * {@inheritdoc}
     */
    public function getPayload()
    {
        return $this->payload;
    }

    /**
     * {@inheritdoc}
     */
    public function withInput($input)
    {
        $jwt = clone $this;
        $jwt->input = $input;

        return $jwt;
    }

    /**
     * {@inheritdoc}
     */
    public function withEncodedProtectedHeaders($encoded_protected_header)
    {
        $jwt = clone $this;
        $jwt->encoded_protected_header = $encoded_protected_header;

        return $jwt;
    }

    /**
     * {@inheritdoc}
     */
    public function withEncodedPayload($encoded_payload)
    {
        $jwt = clone $this;
        $jwt->encoded_payload = $encoded_payload;

        return $jwt;
    }

    /**
     * {@inheritdoc}
     */
    public function withProtectedHeaders(array $values)
    {
        $jwt = clone $this;
        $jwt->protected_headers = $values;

        return $jwt;
    }

    /**
     * {@inheritdoc}
     */
    public function withUnprotectedHeaders(array $values)
    {
        $jwt = clone $this;
        $jwt->unprotected_headers = $values;

        return $jwt;
    }

    /**
     * {@inheritdoc}
     */
    public function withProtectedHeader($key, $value)
    {
        $jwt = clone $this;
        $jwt->protected_headers[$key] = $value;

        return $jwt;
    }

    /**
     * {@inheritdoc}
     */
    public function withUnprotectedHeader($key, $value)
    {
        $jwt = clone $this;
        $jwt->unprotected_headers[$key] = $value;

        return $jwt;
    }

    /**
     * {@inheritdoc}
     */
    public function withPayload($payload)
    {
        $jwt = clone $this;
        $jwt->payload = $payload;

        return $jwt;
    }

    /**
     * {@inheritdoc}
     */
    public function getProtectedHeader($key)
    {
        if ($this->hasProtectedHeader($key)) {
            return $this->protected_headers[$key];
        }
        throw new \InvalidArgumentException(sprintf('The protected header "%" does not exist', $key));
    }

    /**
     * {@inheritdoc}
     */
    public function hasProtectedHeader($key)
    {
        return array_key_exists($key, $this->protected_headers);
    }

    /**
     * {@inheritdoc}
     */
    public function withoutProtectedHeader($key)
    {
        if (!$this->hasProtectedHeader($key)) {
            return $this;
        }
        $jwt = clone $this;
        unset($jwt->protected_headers[$key]);

        return $jwt;
    }

    /**
     * {@inheritdoc}
     */
    public function getUnprotectedHeader($key)
    {
        if ($this->hasUnprotectedHeader($key)) {
            return $this->unprotected_headers[$key];
        }
        throw new \InvalidArgumentException(sprintf('The unprotected header "%" does not exist', $key));
    }

    /**
     * {@inheritdoc}
     */
    public function hasUnprotectedHeader($key)
    {
        return array_key_exists($key, $this->unprotected_headers);
    }

    /**
     * {@inheritdoc}
     */
    public function withoutUnprotectedHeader($key)
    {
        if (!$this->hasUnprotectedHeader($key)) {
            return $this;
        }
        $jwt = clone $this;
        unset($jwt->unprotected_headers[$key]);

        return $jwt;
    }

    /**
     * {@inheritdoc}
     */
    public function getHeaders()
    {
        return array_merge($this->protected_headers, $this->unprotected_headers);
    }

    /**
     * {@inheritdoc}
     */
    public function getHeader($key)
    {
        if ($this->hasProtectedHeader($key)) {
            return $this->getProtectedHeader($key);
        } elseif ($this->hasUnprotectedHeader($key)) {
            return $this->getUnprotectedHeader($key);
        }
        throw new \InvalidArgumentException(sprintf('The protected or unprotected headers do not contain header "%"', $key));
    }

    /**
     * {@inheritdoc}
     */
    public function hasHeader($key)
    {
        return $this->hasProtectedHeader($key) || $this->hasUnprotectedHeader($key);
    }

    /**
     * {@inheritdoc}
     */
    public function getHeaderOrClaim($key)
    {
        if ($this->hasHeader($key)) {
            return $this->getHeader($key);
        } elseif ($this->hasClaim($key)) {
            return $this->getClaim($key);
        }
        throw new \InvalidArgumentException(sprintf('The header or claim do not contain value with key "%"', $key));
    }

    /**
     * {@inheritdoc}
     */
    public function hasHeaderOrClaim($key)
    {
        return $this->hasHeader($key) || $this->hasClaim($key);
    }

    /**
     * {@inheritdoc}
     */
    public function getClaim($key)
    {
        if ($this->hasClaim($key)) {
            return $this->payload[$key];
        }
        throw new \InvalidArgumentException(sprintf('The payload does not contain claim "%"', $key));
    }

    /**
     * {@inheritdoc}
     */
    public function getClaims()
    {
        if (is_array($this->payload)) {
            return $this->payload;
        }
        throw new \InvalidArgumentException('The payload does not contain claims');
    }

    /**
     * {@inheritdoc}
     */
    public function hasClaim($key)
    {
        return $this->hasClaims() && array_key_exists($key, $this->payload);
    }

    /**
     * {@inheritdoc}
     */
    public function hasClaims()
    {
        return is_array($this->payload);
    }

    /**
     * {@inheritdoc}
     */
    public function withClaim($key, $value)
    {
        $jwt = clone $this;
        if (!is_array($jwt->payload)) {
            $jwt->payload = [];

        }
        $jwt->payload[$key] = $value;

        return $jwt;
    }

    /**
     * {@inheritdoc}
     */
    public function withoutClaim($key)
    {
        if (!$this->hasClaim($key)) {
            return $this;
        }
        $jwt = clone $this;
        unset($jwt->payload[$key]);

        return $jwt;
    }

    /**
     * {@inheritdoc}
     */
    public function withClaims(array $claims)
    {
        $jwt = clone $this;
        $jwt->payload = $claims;


        return $jwt;
    }
}


1			<?php
2
3			/*
4			* The MIT License (MIT)
5			*
6			* Copyright (c) 2014-2015 Spomky-Labs
7			*
8			* This software may be modified and distributed under the terms
9			* of the MIT license. See the LICENSE file for details.
10			*/
11
12			namespace Jose\Object;
13
14			/**
15			* Class JWT.
16			*/
17			class JWT implements JWTInterface
18			{
19			/**
20			* @var string
21			*/
22			private $encoded_protected_header = '';
23
24			/**
25			* @var string
26			*/
27			private $input = null;
28
29			/**
30			* @var string
31			*/
32			private $encoded_payload = '';
33
34			/**
35			* @var array
36			*/
37			private $protected_headers = [];
38
39			/**
40			* @var array
41			*/
42			private $unprotected_headers = [];
43
44			/**
45			* @var null
46			*/
47			private $payload = null;
48
49			/**
50			* {@inheritdoc}
51			*/
52			public function getEncodedProtectedHeaders()
53			{
54			return $this->encoded_protected_header;
55			}
56
57			/**
58			* {@inheritdoc}
59			*/
60			public function getInput()
61			{
62			return $this->input;
63			}
64
65			/**
66			* {@inheritdoc}
67			*/
68			public function getEncodedPayload()
69			{
70			return $this->encoded_payload;
71			}
72
73			/**
74			* {@inheritdoc}
75			*/
76			public function getProtectedHeaders()
77			{
78			return $this->protected_headers;
79			}
80
81			/**
82			* {@inheritdoc}
83			*/
84			public function getUnprotectedHeaders()
85			{
86			return $this->unprotected_headers;
87			}
88
89			/**
90			* {@inheritdoc}
91			*/
92			public function getPayload()
93			{
94			return $this->payload;
95			}
96
97			/**
98			* {@inheritdoc}
99			*/
100			public function withInput($input)
101			{
102			$jwt = clone $this;
103			$jwt->input = $input;
104
105			return $jwt;
106			}
107
108			/**
109			* {@inheritdoc}
110			*/
111			public function withEncodedProtectedHeaders($encoded_protected_header)
112			{
113			$jwt = clone $this;
114			$jwt->encoded_protected_header = $encoded_protected_header;
115
116			return $jwt;
117			}
118
119			/**
120			* {@inheritdoc}
121			*/
122			public function withEncodedPayload($encoded_payload)
123			{
124			$jwt = clone $this;
125			$jwt->encoded_payload = $encoded_payload;
126
127			return $jwt;
128			}
129
130			/**
131			* {@inheritdoc}
132			*/
133			public function withProtectedHeaders(array $values)
134			{
135			$jwt = clone $this;
136			$jwt->protected_headers = $values;
137
138			return $jwt;
139			}
140
141			/**
142			* {@inheritdoc}
143			*/
144			public function withUnprotectedHeaders(array $values)
145			{
146			$jwt = clone $this;
147			$jwt->unprotected_headers = $values;
148
149			return $jwt;
150			}
151
152			/**
153			* {@inheritdoc}
154			*/
155			public function withProtectedHeader($key, $value)
156			{
157			$jwt = clone $this;
158			$jwt->protected_headers[$key] = $value;
159
160			return $jwt;
161			}
162
163			/**
164			* {@inheritdoc}
165			*/
166			public function withUnprotectedHeader($key, $value)
167			{
168			$jwt = clone $this;
169			$jwt->unprotected_headers[$key] = $value;
170
171			return $jwt;
172			}
173
174			/**
175			* {@inheritdoc}
176			*/
177			public function withPayload($payload)
178			{
179			$jwt = clone $this;
180			$jwt->payload = $payload;
181
182			return $jwt;
183			}
184
185			/**
186			* {@inheritdoc}
187			*/
188			public function getProtectedHeader($key)
189			{
190			if ($this->hasProtectedHeader($key)) {
191			return $this->protected_headers[$key];
192			}
193			throw new \InvalidArgumentException(sprintf('The protected header "%" does not exist', $key));
194			}
195
196			/**
197			* {@inheritdoc}
198			*/
199			public function hasProtectedHeader($key)
200			{
201			return array_key_exists($key, $this->protected_headers);
202			}
203
204			/**
205			* {@inheritdoc}
206			*/
207			public function withoutProtectedHeader($key)
208			{
209			if (!$this->hasProtectedHeader($key)) {
210			return $this;
211			}
212			$jwt = clone $this;
213			unset($jwt->protected_headers[$key]);
214
215			return $jwt;
216			}
217
218			/**
219			* {@inheritdoc}
220			*/
221			public function getUnprotectedHeader($key)
222			{
223			if ($this->hasUnprotectedHeader($key)) {
224			return $this->unprotected_headers[$key];
225			}
226			throw new \InvalidArgumentException(sprintf('The unprotected header "%" does not exist', $key));
227			}
228
229			/**
230			* {@inheritdoc}
231			*/
232			public function hasUnprotectedHeader($key)
233			{
234			return array_key_exists($key, $this->unprotected_headers);
235			}
236
237			/**
238			* {@inheritdoc}
239			*/
240			public function withoutUnprotectedHeader($key)
241			{
242			if (!$this->hasUnprotectedHeader($key)) {
243			return $this;
244			}
245			$jwt = clone $this;
246			unset($jwt->unprotected_headers[$key]);
247
248			return $jwt;
249			}
250
251			/**
252			* {@inheritdoc}
253			*/
254			public function getHeaders()
255			{
256			return array_merge($this->protected_headers, $this->unprotected_headers);
257			}
258
259			/**
260			* {@inheritdoc}
261			*/
262			public function getHeader($key)
263			{
264			if ($this->hasProtectedHeader($key)) {
265			return $this->getProtectedHeader($key);
266			} elseif ($this->hasUnprotectedHeader($key)) {
267			return $this->getUnprotectedHeader($key);
268			}
269			throw new \InvalidArgumentException(sprintf('The protected or unprotected headers do not contain header "%"', $key));
270			}
271
272			/**
273			* {@inheritdoc}
274			*/
275			public function hasHeader($key)
276			{
277			return $this->hasProtectedHeader($key) \|\| $this->hasUnprotectedHeader($key);
278			}
279
280			/**
281			* {@inheritdoc}
282			*/
283			public function getHeaderOrClaim($key)
284			{
285			if ($this->hasHeader($key)) {
286			return $this->getHeader($key);
287			} elseif ($this->hasClaim($key)) {
288			return $this->getClaim($key);
289			}
290			throw new \InvalidArgumentException(sprintf('The header or claim do not contain value with key "%"', $key));
291			}
292
293			/**
294			* {@inheritdoc}
295			*/
296			public function hasHeaderOrClaim($key)
297			{
298			return $this->hasHeader($key) \|\| $this->hasClaim($key);
299			}
300
301			/**
302			* {@inheritdoc}
303			*/
304			public function getClaim($key)
305			{
306			if ($this->hasClaim($key)) {
307			return $this->payload[$key];
308			}
309			throw new \InvalidArgumentException(sprintf('The payload does not contain claim "%"', $key));
310			}
311
312			/**
313			* {@inheritdoc}
314			*/
315			public function getClaims()
316			{
317			if (is_array($this->payload)) {
318			return $this->payload;
319			}
320			throw new \InvalidArgumentException('The payload does not contain claims');
321			}
322
323			/**
324			* {@inheritdoc}
325			*/
326			public function hasClaim($key)
327			{
328			return $this->hasClaims() && array_key_exists($key, $this->payload);
329			}
330
331			/**
332			* {@inheritdoc}
333			*/
334			public function hasClaims()
335			{
336			return is_array($this->payload);
337			}
338
339			/**
340			* {@inheritdoc}
341			*/
342			public function withClaim($key, $value)
343			{
344			$jwt = clone $this;
345			if (!is_array($jwt->payload)) {
346			$jwt->payload = [];
			0 ignored issues – show Documentation Bug introduced 2015-12-09 21:57 UTC by Report Bug Copy Issue Report It seems like `array()` of type `array` is incompatible with the declared type `null` of property `$payload`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
347			}
348			$jwt->payload[$key] = $value;
349
350			return $jwt;
351			}
352
353			/**
354			* {@inheritdoc}
355			*/
356			public function withoutClaim($key)
357			{
358			if (!$this->hasClaim($key)) {
359			return $this;
360			}
361			$jwt = clone $this;
362			unset($jwt->payload[$key]);
363
364			return $jwt;
365			}
366
367			/**
368			* {@inheritdoc}
369			*/
370			public function withClaims(array $claims)
371			{
372			$jwt = clone $this;
373			$jwt->payload = $claims;
			0 ignored issues – show Documentation Bug introduced 2015-12-09 21:57 UTC by Report Bug Copy Issue Report It seems like `$claims` of type `array` is incompatible with the declared type `null` of property `$payload`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
374
375			return $jwt;
376			}
377			}
378

Spomky-Labs / jose

Push — master ( 668fd8...cdc0a6 )

JWT B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

32 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like