JoseCollector::collectSupportedAlgorithms() - Code Metrics - Inspection of "Data collector updated" - Spomky-Labs/jose - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Push — v7 ( b3d8c9...4e8990 )

by Florent

created 2017-10-03 10:34 UTC

JoseCollector::collectSupportedAlgorithms() A

↳ Parent: JoseCollector

Complexity

Conditions	3
Paths	3

Size

Total Lines	23
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	23
rs	9.0856
c	0
b	0
f	0
cc	3
eloc	16
nc	3
nop	0

<?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\Bundle\JoseFramework\DataCollector;

use Jose\Component\Core\AlgorithmInterface;
use Jose\Component\Core\AlgorithmManagerFactory;
use Jose\Component\Encryption\Algorithm\ContentEncryptionAlgorithmInterface;
use Jose\Component\Encryption\Algorithm\KeyEncryptionAlgorithmInterface;
use Jose\Component\Encryption\Compression\CompressionMethodManagerFactory;
use Jose\Component\Encryption\Serializer\JWESerializerManagerFactory;
use Jose\Component\Signature\Algorithm\SignatureAlgorithmInterface;
use Jose\Component\Signature\Serializer\JWSSerializerManagerFactory;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\DataCollector\DataCollector;

final class JoseCollector extends DataCollector
{
    /**
     * @var AlgorithmManagerFactory
     */
    private $algorithmManagerFactory;

    /**
     * @var CompressionMethodManagerFactory|null
     */
    private $compressionMethodManagerFactory;

    /**
     * @var JWSSerializerManagerFactory|null
     */
    private $jwsSerializerManagerFactory;

    /**
     * @var JWESerializerManagerFactory|null
     */
    private $jweSerializerManagerFactory;

    /**
     * JoseCollector constructor.
     *
     * @param AlgorithmManagerFactory              $algorithmManagerFactory
     * @param CompressionMethodManagerFactory|null $compressionMethodManagerFactory
     * @param JWSSerializerManagerFactory|null     $jwsSerializerManagerFactory
     * @param JWESerializerManagerFactory|null     $jweSerializerManagerFactory
     */
    public function __construct(AlgorithmManagerFactory $algorithmManagerFactory, ?CompressionMethodManagerFactory $compressionMethodManagerFactory = null, ?JWSSerializerManagerFactory $jwsSerializerManagerFactory = null, ?JWESerializerManagerFactory $jweSerializerManagerFactory = null)
    {
        $this->data = [];
        $this->algorithmManagerFactory = $algorithmManagerFactory;
        $this->compressionMethodManagerFactory = $compressionMethodManagerFactory;
        $this->jwsSerializerManagerFactory = $jwsSerializerManagerFactory;
        $this->jweSerializerManagerFactory = $jweSerializerManagerFactory;
    }

    /**
     * {@inheritdoc}
     */
    public function collect(Request $request, Response $response, \Exception $exception = null)
    {
        $this->collectSupportedAlgorithms();
        $this->collectSupportedCompressionMethods();
        $this->collectSupportedJWSSerializations();
        $this->collectSupportedJWESerializations();
    }

    /**
     * @return array
     */
    public function getAlgorithmDetails(): array
    {
        return $this->data['algorithms'];
    }

    /**
     * @return int
     */
    public function countSignatureAlgorithms(): int
    {
        return $this->data['types']['signature'];
    }

    /**
     * @return int
     */
    public function countKeyEncryptionAlgorithms(): int
    {
        return $this->data['types']['key_encryption'];
    }

    /**
     * @return int
     */
    public function countContentEncryptionAlgorithms(): int
    {
        return $this->data['types']['content_encryption'];
    }

    /**
     * @return array
     */
    public function getCompressionMethodDetails(): array
    {
        return $this->data['compression_methods'];
    }

    /**
     * @return array
     */
    public function getJWSSerializationDetails(): array
    {
        return $this->data['jws_serialization'];
    }

    /**
     * @return array
     */
    public function getJWESerializationDetails(): array
    {
        return $this->data['jwe_serialization'];
    }

    /**
     * {@inheritdoc}
     */
    public function getName()
    {
        return 'jose_collector';
    }

    /**
     *
     */
    private function collectSupportedAlgorithms()
    {
        $algorithms = $this->algorithmManagerFactory->all();
        $this->data['algorithms'] = [];
        $signatureAlgorithms = 0;
        $keyEncryptionAlgorithms = 0;
        $contentEncryptionAlgorithms = 0;
        foreach ($algorithms as $alias => $algorithm) {
            $type = $this->getAlgorithmType($algorithm, $signatureAlgorithms, $keyEncryptionAlgorithms, $contentEncryptionAlgorithms);
            if (!array_key_exists($type, $this->data['algorithms'])) {
                $this->data['algorithms'][$type] = [];
            }
            $this->data['algorithms'][$type][$alias] = [
                'name' => $algorithm->name(),
            ];
        }

        $this->data['types'] = [
            'signature' => $signatureAlgorithms,
            'key_encryption' => $keyEncryptionAlgorithms,
            'content_encryption' => $contentEncryptionAlgorithms,
        ];
    }

    /**
     * @param AlgorithmInterface $algorithm
     * @param int $signatureAlgorithms
     * @param int $keyEncryptionAlgorithms
     * @param int $contentEncryptionAlgorithms
     *
     * @return string
     */
    private function getAlgorithmType(AlgorithmInterface $algorithm, int &$signatureAlgorithms, int &$keyEncryptionAlgorithms, int &$contentEncryptionAlgorithms): string
    {
        switch (true) {
            case $algorithm instanceof SignatureAlgorithmInterface:
                $signatureAlgorithms++;

                return 'Signature';
            case $algorithm instanceof KeyEncryptionAlgorithmInterface:
                $keyEncryptionAlgorithms++;

                return 'Key Encryption';
            case $algorithm instanceof ContentEncryptionAlgorithmInterface:
                $contentEncryptionAlgorithms++;

                return 'Content Encryption';
            default:
                return 'Unknown';
        }
    }

    private function collectSupportedCompressionMethods()
    {
        $this->data['compression_methods'] = [];
        if (null === $this->compressionMethodManagerFactory) {
            return;
        }
        $compressionMethods = $this->compressionMethodManagerFactory->all();
        foreach ($compressionMethods as $alias => $compressionMethod) {
            $this->data['compression_methods'][$alias] = $compressionMethod->name();
        }
    }

    private function collectSupportedJWSSerializations()
    {
        $this->data['jws_serialization'] = [];
        if (null === $this->jwsSerializerManagerFactory) {
            return;
        }
        $serializers = $this->jwsSerializerManagerFactory->all();
        foreach ($serializers as $serializer) {
            $this->data['jws_serialization'][$serializer->name()] = $serializer->displayName();
        }
    }

    private function collectSupportedJWESerializations()
    {
        $this->data['jwe_serialization'] = [];
        if (null === $this->jweSerializerManagerFactory) {
            return;
        }
        $serializers = $this->jweSerializerManagerFactory->all();
        foreach ($serializers as $serializer) {
            $this->data['jwe_serialization'][$serializer->name()] = $serializer->displayName();
        }
    }
}


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\Bundle\JoseFramework\DataCollector;
15
16			use Jose\Component\Core\AlgorithmInterface;
17			use Jose\Component\Core\AlgorithmManagerFactory;
18			use Jose\Component\Encryption\Algorithm\ContentEncryptionAlgorithmInterface;
19			use Jose\Component\Encryption\Algorithm\KeyEncryptionAlgorithmInterface;
20			use Jose\Component\Encryption\Compression\CompressionMethodManagerFactory;
21			use Jose\Component\Encryption\Serializer\JWESerializerManagerFactory;
22			use Jose\Component\Signature\Algorithm\SignatureAlgorithmInterface;
23			use Jose\Component\Signature\Serializer\JWSSerializerManagerFactory;
24			use Symfony\Component\HttpFoundation\Request;
25			use Symfony\Component\HttpFoundation\Response;
26			use Symfony\Component\HttpKernel\DataCollector\DataCollector;
27
28			final class JoseCollector extends DataCollector
29			{
30			/**
31			* @var AlgorithmManagerFactory
32			*/
33			private $algorithmManagerFactory;
34
35			/**
36			* @var CompressionMethodManagerFactory\|null
37			*/
38			private $compressionMethodManagerFactory;
39
40			/**
41			* @var JWSSerializerManagerFactory\|null
42			*/
43			private $jwsSerializerManagerFactory;
44
45			/**
46			* @var JWESerializerManagerFactory\|null
47			*/
48			private $jweSerializerManagerFactory;
49
50			/**
51			* JoseCollector constructor.
52			*
53			* @param AlgorithmManagerFactory $algorithmManagerFactory
54			* @param CompressionMethodManagerFactory\|null $compressionMethodManagerFactory
55			* @param JWSSerializerManagerFactory\|null $jwsSerializerManagerFactory
56			* @param JWESerializerManagerFactory\|null $jweSerializerManagerFactory
57			*/
58			public function __construct(AlgorithmManagerFactory $algorithmManagerFactory, ?CompressionMethodManagerFactory $compressionMethodManagerFactory = null, ?JWSSerializerManagerFactory $jwsSerializerManagerFactory = null, ?JWESerializerManagerFactory $jweSerializerManagerFactory = null)
59			{
60			$this->data = [];
61			$this->algorithmManagerFactory = $algorithmManagerFactory;
62			$this->compressionMethodManagerFactory = $compressionMethodManagerFactory;
63			$this->jwsSerializerManagerFactory = $jwsSerializerManagerFactory;
64			$this->jweSerializerManagerFactory = $jweSerializerManagerFactory;
65			}
66
67			/**
68			* {@inheritdoc}
69			*/
70			public function collect(Request $request, Response $response, \Exception $exception = null)
71			{
72			$this->collectSupportedAlgorithms();
73			$this->collectSupportedCompressionMethods();
74			$this->collectSupportedJWSSerializations();
75			$this->collectSupportedJWESerializations();
76			}
77
78			/**
79			* @return array
80			*/
81			public function getAlgorithmDetails(): array
82			{
83			return $this->data['algorithms'];
84			}
85
86			/**
87			* @return int
88			*/
89			public function countSignatureAlgorithms(): int
90			{
91			return $this->data['types']['signature'];
92			}
93
94			/**
95			* @return int
96			*/
97			public function countKeyEncryptionAlgorithms(): int
98			{
99			return $this->data['types']['key_encryption'];
100			}
101
102			/**
103			* @return int
104			*/
105			public function countContentEncryptionAlgorithms(): int
106			{
107			return $this->data['types']['content_encryption'];
108			}
109
110			/**
111			* @return array
112			*/
113			public function getCompressionMethodDetails(): array
114			{
115			return $this->data['compression_methods'];
116			}
117
118			/**
119			* @return array
120			*/
121			public function getJWSSerializationDetails(): array
122			{
123			return $this->data['jws_serialization'];
124			}
125
126			/**
127			* @return array
128			*/
129			public function getJWESerializationDetails(): array
130			{
131			return $this->data['jwe_serialization'];
132			}
133
134			/**
135			* {@inheritdoc}
136			*/
137			public function getName()
138			{
139			return 'jose_collector';
140			}
141
142			/**
143			*
144			*/
145			private function collectSupportedAlgorithms()
146			{
147			$algorithms = $this->algorithmManagerFactory->all();
148			$this->data['algorithms'] = [];
149			$signatureAlgorithms = 0;
150			$keyEncryptionAlgorithms = 0;
151			$contentEncryptionAlgorithms = 0;
152			foreach ($algorithms as $alias => $algorithm) {
153			$type = $this->getAlgorithmType($algorithm, $signatureAlgorithms, $keyEncryptionAlgorithms, $contentEncryptionAlgorithms);
154			if (!array_key_exists($type, $this->data['algorithms'])) {
155			$this->data['algorithms'][$type] = [];
156			}
157			$this->data['algorithms'][$type][$alias] = [
158			'name' => $algorithm->name(),
159			];
160			}
161
162			$this->data['types'] = [
163			'signature' => $signatureAlgorithms,
164			'key_encryption' => $keyEncryptionAlgorithms,
165			'content_encryption' => $contentEncryptionAlgorithms,
166			];
167			}
168
169			/**
170			* @param AlgorithmInterface $algorithm
171			* @param int $signatureAlgorithms
172			* @param int $keyEncryptionAlgorithms
173			* @param int $contentEncryptionAlgorithms
174			*
175			* @return string
176			*/
177			private function getAlgorithmType(AlgorithmInterface $algorithm, int &$signatureAlgorithms, int &$keyEncryptionAlgorithms, int &$contentEncryptionAlgorithms): string
178			{
179			switch (true) {
180			case $algorithm instanceof SignatureAlgorithmInterface:
181			$signatureAlgorithms++;
182
183			return 'Signature';
184			case $algorithm instanceof KeyEncryptionAlgorithmInterface:
185			$keyEncryptionAlgorithms++;
186
187			return 'Key Encryption';
188			case $algorithm instanceof ContentEncryptionAlgorithmInterface:
189			$contentEncryptionAlgorithms++;
190
191			return 'Content Encryption';
192			default:
193			return 'Unknown';
194			}
195			}
196
197			private function collectSupportedCompressionMethods()
198			{
199			$this->data['compression_methods'] = [];
200			if (null === $this->compressionMethodManagerFactory) {
201			return;
202			}
203			$compressionMethods = $this->compressionMethodManagerFactory->all();
204			foreach ($compressionMethods as $alias => $compressionMethod) {
205			$this->data['compression_methods'][$alias] = $compressionMethod->name();
206			}
207			}
208
209			private function collectSupportedJWSSerializations()
210			{
211			$this->data['jws_serialization'] = [];
212			if (null === $this->jwsSerializerManagerFactory) {
213			return;
214			}
215			$serializers = $this->jwsSerializerManagerFactory->all();
216			foreach ($serializers as $serializer) {
217			$this->data['jws_serialization'][$serializer->name()] = $serializer->displayName();
218			}
219			}
220
221			private function collectSupportedJWESerializations()
222			{
223			$this->data['jwe_serialization'] = [];
224			if (null === $this->jweSerializerManagerFactory) {
225			return;
226			}
227			$serializers = $this->jweSerializerManagerFactory->all();
228			foreach ($serializers as $serializer) {
229			$this->data['jwe_serialization'][$serializer->name()] = $serializer->displayName();
230			}
231			}
232			}
233

Spomky-Labs / jose

Push — v7 ( b3d8c9...4e8990 )

JoseCollector::collectSupportedAlgorithms() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like