RevocationEndPoint - Code Metrics - b2pweb/parroauth2-client - Measure and Improve Code Quality continuously with Scrutinizer

RevocationEndPoint A
last analyzed 2023-02-10 10:37 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	120
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
wmc	8
eloc	22
c	1
b	0
f	0
dl	0
loc	120
ccs	24
cts	24
cp	1
rs	10

8 Methods

Rating	Name	Size	Complexity
A	call()	14	1
A	typeHint()	3	1
A	apply()	3	1
A	accessToken()	3	1
A	__construct()	3	1
A	name()	3	1
A	refreshToken()	3	1
A	token()	3	1

<?php

namespace Parroauth2\Client\EndPoint\Token;

use Parroauth2\Client\ClientInterface;
use Parroauth2\Client\EndPoint\CallableEndPointInterface;
use Parroauth2\Client\EndPoint\EndPointParametersTrait;
use Parroauth2\Client\EndPoint\EndPointResponseListenerTrait;
use Parroauth2\Client\EndPoint\EndPointTransformerInterface;
use Psr\Http\Message\ResponseInterface;

/**
 * The token revocation endpoint
 *
 * @see https://tools.ietf.org/html/rfc7009
 *
 * @implements CallableEndPointInterface<ResponseInterface>
 */
class RevocationEndPoint implements CallableEndPointInterface
{
    use EndPointParametersTrait;
    /** @use EndPointResponseListenerTrait<ResponseInterface> */
    use EndPointResponseListenerTrait;

    public const NAME = 'revocation';

    public const TYPE_ACCESS_TOKEN = 'access_token';
    public const TYPE_REFRESH_TOKEN = 'refresh_token';

    /**
     * @var ClientInterface
     * @readonly
     */
    private $client;


    /**
     * RevocationEndPoint constructor.
     *
     * @param ClientInterface $client
     */
    public function __construct(ClientInterface $client)
    {
        $this->client = $client;
    }

    /**
     * {@inheritdoc}
     *
     * @psalm-mutation-free
     */
    public function name(): string
    {
        return self::NAME;
    }

    /**
     * {@inheritdoc}
     */
    public function apply(EndPointTransformerInterface $transformer): RevocationEndPoint
    {
        return $transformer->onRevocation($this);
    }

    /**
     * Define the token to revoke
     *
     * @param string $token Token to revoke. May be an access token or a refresh token
     *
     * @return static
     *
     * @psalm-mutation-free
     */
    public function token(string $token): RevocationEndPoint
    {
        return $this->set('token', $token);
    }

    /**
     * Define the token type
     * The server can ignore this value if not match with the token
     *
     * @param string $type the token type
     *
     * @return static
     *
     * @psalm-mutation-free
     */
    public function typeHint(string $type): RevocationEndPoint
    {
        return $this->set('token_type_hint', $type);
    }

    /**
     * Try to revoke an access token
     *
     * @param string $token The access token
     *
     * @return static
     *
     * @psalm-mutation-free
     */
    public function accessToken(string $token): RevocationEndPoint
    {
        return $this->token($token)->typeHint(self::TYPE_ACCESS_TOKEN);
    }

    /**
     * Try to revoke a refresh token
     *
     * @param string $token The refresh token
     *
     * @return static
     *
     * @psalm-mutation-free
     */
    public function refreshToken(string $token): RevocationEndPoint
    {
        return $this->token($token)->typeHint(self::TYPE_REFRESH_TOKEN);
    }

    /**
     * {@inheritdoc}
     */
    public function call(): ResponseInterface
    {
        $request = $this->client->endPoints()
            ->request('POST', $this)
            ->withHeader(
                'Authorization',
                'Basic ' . base64_encode($this->client->clientId() . ':' . $this->client->secret())
            )
        ;

        $response = $this->client->provider()->sendRequest($request);
        $this->callResponseListeners($response);

        return $response;
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }
}


1		<?php
2
3		namespace Parroauth2\Client\EndPoint\Token;
4
5		use Parroauth2\Client\ClientInterface;
6		use Parroauth2\Client\EndPoint\CallableEndPointInterface;
7		use Parroauth2\Client\EndPoint\EndPointParametersTrait;
8		use Parroauth2\Client\EndPoint\EndPointResponseListenerTrait;
9		use Parroauth2\Client\EndPoint\EndPointTransformerInterface;
10		use Psr\Http\Message\ResponseInterface;
11
12		/**
13		* The token revocation endpoint
14		*
15		* @see https://tools.ietf.org/html/rfc7009
16		*
17		* @implements CallableEndPointInterface<ResponseInterface>
18		*/
19		class RevocationEndPoint implements CallableEndPointInterface
20		{
21		use EndPointParametersTrait;
22		/** @use EndPointResponseListenerTrait<ResponseInterface> */
23		use EndPointResponseListenerTrait;
24
25		public const NAME = 'revocation';
26
27		public const TYPE_ACCESS_TOKEN = 'access_token';
28		public const TYPE_REFRESH_TOKEN = 'refresh_token';
29
30		/**
31		* @var ClientInterface
32		* @readonly
33		*/
34		private $client;
35
36
37		/**
38		* RevocationEndPoint constructor.
39		*
40		* @param ClientInterface $client
41		*/
42	142	public function __construct(ClientInterface $client)
43		{
44	142	$this->client = $client;
45	142	}
46
47		/**
48		* {@inheritdoc}
49		*
50		* @psalm-mutation-free
51		*/
52	142	public function name(): string
53		{
54	142	return self::NAME;
55		}
56
57		/**
58		* {@inheritdoc}
59		*/
60	3	public function apply(EndPointTransformerInterface $transformer): RevocationEndPoint
61		{
62	3	return $transformer->onRevocation($this);
63		}
64
65		/**
66		* Define the token to revoke
67		*
68		* @param string $token Token to revoke. May be an access token or a refresh token
69		*
70		* @return static
71		*
72		* @psalm-mutation-free
73		*/
74	5	public function token(string $token): RevocationEndPoint
75		{
76	5	return $this->set('token', $token);
77		}
78
79		/**
80		* Define the token type
81		* The server can ignore this value if not match with the token
82		*
83		* @param string $type the token type
84		*
85		* @return static
86		*
87		* @psalm-mutation-free
88		*/
89	5	public function typeHint(string $type): RevocationEndPoint
90		{
91	5	return $this->set('token_type_hint', $type);
92		}
93
94		/**
95		* Try to revoke an access token
96		*
97		* @param string $token The access token
98		*
99		* @return static
100		*
101		* @psalm-mutation-free
102		*/
103	4	public function accessToken(string $token): RevocationEndPoint
104		{
105	4	return $this->token($token)->typeHint(self::TYPE_ACCESS_TOKEN);
106		}
107
108		/**
109		* Try to revoke a refresh token
110		*
111		* @param string $token The refresh token
112		*
113		* @return static
114		*
115		* @psalm-mutation-free
116		*/
117	1	public function refreshToken(string $token): RevocationEndPoint
118		{
119	1	return $this->token($token)->typeHint(self::TYPE_REFRESH_TOKEN);
120		}
121
122		/**
123		* {@inheritdoc}
124		*/
125	5	public function call(): ResponseInterface
126		{
127	5	$request = $this->client->endPoints()
128	5	->request('POST', $this)
129	5	->withHeader(
130	5	'Authorization',
131	5	'Basic ' . base64_encode($this->client->clientId() . ':' . $this->client->secret())
132		)
133		;
134
135	5	$response = $this->client->provider()->sendRequest($request);
136	5	$this->callResponseListeners($response);
137
138	5	return $response;
		0 ignored issues – show Bug Best Practice introduced 2021-10-08 10:23 UTC by Report Bug Copy Issue Report The expression `return $response` returns the type `Psr\Http\Message\ResponseInterface` which is incompatible with the return type mandated by `Parroauth2\Client\EndPoi...dPointInterface::call()` of `Parroauth2\Client\EndPoint\T`. In the issue above, the returned value is violating the contract defined by the mentioned interface. Let's take a look at an example: interface HasName { /** @return string / public function getName(); } class Name { public $name; } class User implements HasName { /* @return string\|Name */ public function getName() { return new Name('foo'); // This is a violation of the ``HasName`` interface // which only allows a string value to be returned. } } Loading history...
139		}
140		}
141

b2pweb / parroauth2-client

RevocationEndPoint A last analyzed 2023-02-10 10:37 UTC

Complexity

Size/Duplication

Test Coverage

Importance

8 Methods

Duplication Side-by-Side

Filter issues like

RevocationEndPoint A
last analyzed 2023-02-10 10:37 UTC