HeaderCheckerManager::checkHeaders() - Code Metrics - Inspection of "Checker Component split" - web-token/jwt-framework - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Push — master ( 8befd5...3eda38 )

by Florent

created 2017-10-08 11:36 UTC

HeaderCheckerManager::checkHeaders() D

↳ Parent: HeaderCheckerManager

Complexity

Conditions	10
Paths	26

Size

Total Lines	34
Code Lines	24

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	34
rs	4.8196
c	0
b	0
f	0
cc	10
eloc	24
nc	26
nop	2

How to fix Complexity

<?php

declare(strict_types=1);

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

namespace Jose\Component\Checker;

use Jose\Component\Core\JWTInterface;

/**
 * Class HeaderCheckerManager.
 */
final class HeaderCheckerManager
{
    /**
     * @var HeaderCheckerInterface[]
     */
    private $checkers = [];

    /**
     * @var TokenTypeHeaderCheckerInterface[]
     */
    private $tokenTypes = [];

    /**
     * HeaderCheckerManager constructor.
     *
     * @param HeaderCheckerInterface[]          $checkers
     * @param TokenTypeHeaderCheckerInterface[] $tokenTypes
     */
    private function __construct(array $checkers, array $tokenTypes)
    {
        foreach ($checkers as $checker) {
            $this->add($checker);
        }
        foreach ($tokenTypes as $tokenType) {
            $this->addTokenTypeSupport($tokenType);
        }
    }

    /**
     * @param HeaderCheckerInterface[]          $checkers
     * @param TokenTypeHeaderCheckerInterface[] $tokenTypes
     *
     * @return HeaderCheckerManager
     */
    public static function create(array $checkers, array $tokenTypes): HeaderCheckerManager
    {
        return new self($checkers, $tokenTypes);
    }

    /**
     * @param TokenTypeHeaderCheckerInterface $tokenType
     *
     * @return HeaderCheckerManager
     */
    private function addTokenTypeSupport(TokenTypeHeaderCheckerInterface $tokenType): HeaderCheckerManager
    {
        $this->tokenTypes[] = $tokenType;

        return $this;
    }

    /**
     * @param HeaderCheckerInterface $checker
     *
     * @return HeaderCheckerManager
     */
    private function add(HeaderCheckerInterface $checker): HeaderCheckerManager
    {
        $header = $checker->supportedHeader();
        if (array_key_exists($header, $this->checkers)) {
            throw new \InvalidArgumentException(sprintf('The header checker "%s" is already supported.', $header));
        }

        $this->checkers[$header] = $checker;

        return $this;
    }

    /**
     * @param JWTInterface $jwt
     * @param int          $component
     */
    public function check(JWTInterface $jwt, int $component)
    {
        foreach ($this->tokenTypes as $tokenType) {
            if ($tokenType->supports($jwt)) {
                $protected = [];
                $unprotected = [];
                $tokenType->retrieveTokenHeaders($jwt, $component, $protected, $unprotected);
                $this->checkDuplicatedHeaderParameters($protected, $unprotected);
                $this->checkHeaders($protected, $unprotected);

                return;
            }
        }
        throw new \InvalidArgumentException('Unsupported token type.');
    }

    /**
     * @param array $header1
     * @param array $header2
     */
    private function checkDuplicatedHeaderParameters(array $header1, array $header2)
    {
        $inter = array_intersect_key($header1, $header2);
        if (!empty($inter)) {
            throw new \InvalidArgumentException(sprintf('The header contains duplicated entries: %s.', implode(', ', array_keys($inter))));
        }
    }

    /**
     * @param array $protected
     * @param array $headers
     */
    private function checkHeaders(array $protected, array $headers)
    {
        $checkedHeaders = [];
        foreach ($this->checkers as $header => $checker) {
            if ($checker->protectedHeaderOnly()) {
                if (array_key_exists($header, $protected)) {
                    $checker->checkHeader($protected[$header]);
                    $checkedHeaders[] = $header;
                } else {
                    throw new \InvalidArgumentException(sprintf('The header "%s" must be protected.', $header));
                }
            } else {
                if (array_key_exists($header, $protected)) {
                    $checker->checkHeader($protected[$header]);
                    $checkedHeaders[] = $header;
                } elseif (array_key_exists($header, $headers)) {
                    $checker->checkHeader($headers[$header]);
                    $checkedHeaders[] = $header;
                }
            }
        }

        if (array_key_exists('crit', $protected)) {
            if (!is_array($protected['crit'])) {
                throw new \InvalidArgumentException('The header "crit" mus be a list of header parameters.');
            }
            $diff = array_diff($protected['crit'], $checkedHeaders);
            if (!empty($diff)) {
                throw new \InvalidArgumentException(sprintf('One or more headers are marked as critical, but they are missing or have not been checked: %s.', implode(', ', array_values($diff))));
            }
        } elseif (array_key_exists('crit', $headers)) {
            throw new \InvalidArgumentException('The header parameter "crit" must be protected.');
        }
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* The MIT License (MIT)
7			*
8			* Copyright (c) 2014-2017 Spomky-Labs
9			*
10			* This software may be modified and distributed under the terms
11			* of the MIT license. See the LICENSE file for details.
12			*/
13
14			namespace Jose\Component\Checker;
15
16			use Jose\Component\Core\JWTInterface;
17
18			/**
19			* Class HeaderCheckerManager.
20			*/
21			final class HeaderCheckerManager
22			{
23			/**
24			* @var HeaderCheckerInterface[]
25			*/
26			private $checkers = [];
27
28			/**
29			* @var TokenTypeHeaderCheckerInterface[]
30			*/
31			private $tokenTypes = [];
32
33			/**
34			* HeaderCheckerManager constructor.
35			*
36			* @param HeaderCheckerInterface[] $checkers
37			* @param TokenTypeHeaderCheckerInterface[] $tokenTypes
38			*/
39			private function __construct(array $checkers, array $tokenTypes)
40			{
41			foreach ($checkers as $checker) {
42			$this->add($checker);
43			}
44			foreach ($tokenTypes as $tokenType) {
45			$this->addTokenTypeSupport($tokenType);
46			}
47			}
48
49			/**
50			* @param HeaderCheckerInterface[] $checkers
51			* @param TokenTypeHeaderCheckerInterface[] $tokenTypes
52			*
53			* @return HeaderCheckerManager
54			*/
55			public static function create(array $checkers, array $tokenTypes): HeaderCheckerManager
56			{
57			return new self($checkers, $tokenTypes);
58			}
59
60			/**
61			* @param TokenTypeHeaderCheckerInterface $tokenType
62			*
63			* @return HeaderCheckerManager
64			*/
65			private function addTokenTypeSupport(TokenTypeHeaderCheckerInterface $tokenType): HeaderCheckerManager
66			{
67			$this->tokenTypes[] = $tokenType;
68
69			return $this;
70			}
71
72			/**
73			* @param HeaderCheckerInterface $checker
74			*
75			* @return HeaderCheckerManager
76			*/
77			private function add(HeaderCheckerInterface $checker): HeaderCheckerManager
78			{
79			$header = $checker->supportedHeader();
80			if (array_key_exists($header, $this->checkers)) {
81			throw new \InvalidArgumentException(sprintf('The header checker "%s" is already supported.', $header));
82			}
83
84			$this->checkers[$header] = $checker;
85
86			return $this;
87			}
88
89			/**
90			* @param JWTInterface $jwt
91			* @param int $component
92			*/
93			public function check(JWTInterface $jwt, int $component)
94			{
95			foreach ($this->tokenTypes as $tokenType) {
96			if ($tokenType->supports($jwt)) {
97			$protected = [];
98			$unprotected = [];
99			$tokenType->retrieveTokenHeaders($jwt, $component, $protected, $unprotected);
100			$this->checkDuplicatedHeaderParameters($protected, $unprotected);
101			$this->checkHeaders($protected, $unprotected);
102
103			return;
104			}
105			}
106			throw new \InvalidArgumentException('Unsupported token type.');
107			}
108
109			/**
110			* @param array $header1
111			* @param array $header2
112			*/
113			private function checkDuplicatedHeaderParameters(array $header1, array $header2)
114			{
115			$inter = array_intersect_key($header1, $header2);
116			if (!empty($inter)) {
117			throw new \InvalidArgumentException(sprintf('The header contains duplicated entries: %s.', implode(', ', array_keys($inter))));
118			}
119			}
120
121			/**
122			* @param array $protected
123			* @param array $headers
124			*/
125			private function checkHeaders(array $protected, array $headers)
126			{
127			$checkedHeaders = [];
128			foreach ($this->checkers as $header => $checker) {
129			if ($checker->protectedHeaderOnly()) {
130			if (array_key_exists($header, $protected)) {
131			$checker->checkHeader($protected[$header]);
132			$checkedHeaders[] = $header;
133			} else {
134			throw new \InvalidArgumentException(sprintf('The header "%s" must be protected.', $header));
135			}
136			} else {
137			if (array_key_exists($header, $protected)) {
138			$checker->checkHeader($protected[$header]);
139			$checkedHeaders[] = $header;
140			} elseif (array_key_exists($header, $headers)) {
141			$checker->checkHeader($headers[$header]);
142			$checkedHeaders[] = $header;
143			}
144			}
145			}
146
147			if (array_key_exists('crit', $protected)) {
148			if (!is_array($protected['crit'])) {
149			throw new \InvalidArgumentException('The header "crit" mus be a list of header parameters.');
150			}
151			$diff = array_diff($protected['crit'], $checkedHeaders);
152			if (!empty($diff)) {
153			throw new \InvalidArgumentException(sprintf('One or more headers are marked as critical, but they are missing or have not been checked: %s.', implode(', ', array_values($diff))));
154			}
155			} elseif (array_key_exists('crit', $headers)) {
156			throw new \InvalidArgumentException('The header parameter "crit" must be protected.');
157			}
158			}
159			}
160

web-token / jwt-framework

Push — master ( 8befd5...3eda38 )

HeaderCheckerManager::checkHeaders() D

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like