AttributeMap::map() - Code Metrics - gyselroth/micro-auth - Measure and Improve Code Quality continuously with Scrutinizer

AttributeMap::map() B
last analyzed 2019-04-12 14:15 UTC

↳ Parent: AttributeMap

Complexity

Conditions	10
Paths	32

Size

Total Lines	56
Code Lines	36

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	36
dl	0
loc	56
c	0
b	0
f	0
rs	7.6666
cc	10
nc	32
nop	1

How to fix Long Method Complexity

<?php

declare(strict_types=1);

/**
 * Micro
 *
 * @copyright   Copryright (c) 2015-2018 gyselroth GmbH (https://gyselroth.com)
 * @license     MIT https://opensource.org/licenses/MIT
 */

namespace Micro\Auth;

use Closure;
use Psr\Log\LoggerInterface as Logger;

class AttributeMap implements AttributeMapInterface
{
    /**
     * Attribute map.
     *
     * @var iterable
     */
    protected $map = [];

    /**
     * Logger.
     *
     * @var Logger
     */
    protected $logger;

    /**
     * Custom mapper.
     *
     * @var array
     */
    protected $mapper = [];

    /**
     * Initialize.
     *
     * @param iterable $map
     * @param Logger   $logger
     */
    public function __construct(Iterable $map, Logger $logger)
    {
        $this->logger = $logger;
        $this->map = $map;
    }

    /**
     * {@inheritdoc}
     */
    public function getAttributeMap(): Iterable
    {
        return $this->map;
    }

    /**
     * {@inheritdoc}
     */
    public function addMapper(string $type, Closure $closure): AttributeMapInterface
    {
        $this->mapper[$type] = $closure;

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function map(array $data): array
    {
        $attrs = [];
        foreach ($this->map as $attr => $value) {
            if (array_key_exists($value['attr'], $data)) {
                $this->logger->info('found attribute mapping ['.$attr.'] => [('.$value['type'].') '.$value['attr'].']', [
                    'category' => get_class($this),
                ]);

                if ('array' === $value['type']) {
                    $store = $data[$value['attr']];
                } else {
                    $store = $data[$value['attr']];
                    if (is_array($store)) {
                        $store = $store[0];
                    }
                }

                if (isset($this->mapper[$value['type']])) {
                    $attrs[$attr] = $this->mapper[$value['type']]->call($this, $store);
                }

                switch ($value['type']) {
                    case 'array':
                        $arr = (array) $data[$value['attr']];
                        unset($arr['count']);
                        $attrs[$attr] = $arr;

                    break;
                    case 'string':
                         $attrs[$attr] = (string) $store;

                    break;
                    case 'int':
                         $attrs[$attr] = (int) $store;

                    break;
                    case 'bool':
                         $attrs[$attr] = (bool) $store;

                    break;
                    default:
                        $this->logger->error('unknown attribute type ['.$value['type'].'] for attribute ['.$attr.']; use one of [array,string,int,bool]', [
                            'category' => get_class($this),
                        ]);

                    break;
                }
            } else {
                $this->logger->warning('auth attribute ['.$value['attr'].'] was not found from authentication adapter response', [
                    'category' => get_class($this),
                ]);
            }
        }

        return $attrs;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/**
6			* Micro
7			*
8			* @copyright Copryright (c) 2015-2018 gyselroth GmbH (https://gyselroth.com)
9			* @license MIT https://opensource.org/licenses/MIT
10			*/
11
12			namespace Micro\Auth;
13
14			use Closure;
15			use Psr\Log\LoggerInterface as Logger;
16
17			class AttributeMap implements AttributeMapInterface
18			{
19			/**
20			* Attribute map.
21			*
22			* @var iterable
23			*/
24			protected $map = [];
25
26			/**
27			* Logger.
28			*
29			* @var Logger
30			*/
31			protected $logger;
32
33			/**
34			* Custom mapper.
35			*
36			* @var array
37			*/
38			protected $mapper = [];
39
40			/**
41			* Initialize.
42			*
43			* @param iterable $map
44			* @param Logger $logger
45			*/
46			public function __construct(Iterable $map, Logger $logger)
47			{
48			$this->logger = $logger;
49			$this->map = $map;
50			}
51
52			/**
53			* {@inheritdoc}
54			*/
55			public function getAttributeMap(): Iterable
56			{
57			return $this->map;
58			}
59
60			/**
61			* {@inheritdoc}
62			*/
63			public function addMapper(string $type, Closure $closure): AttributeMapInterface
64			{
65			$this->mapper[$type] = $closure;
66
67			return $this;
68			}
69
70			/**
71			* {@inheritdoc}
72			*/
73			public function map(array $data): array
74			{
75			$attrs = [];
76			foreach ($this->map as $attr => $value) {
77			if (array_key_exists($value['attr'], $data)) {
78			$this->logger->info('found attribute mapping ['.$attr.'] => [('.$value['type'].') '.$value['attr'].']', [
79			'category' => get_class($this),
80			]);
81
82			if ('array' === $value['type']) {
83			$store = $data[$value['attr']];
84			} else {
85			$store = $data[$value['attr']];
86			if (is_array($store)) {
87			$store = $store[0];
88			}
89			}
90
91			if (isset($this->mapper[$value['type']])) {
92			$attrs[$attr] = $this->mapper[$value['type']]->call($this, $store);
93			}
94
95			switch ($value['type']) {
96			case 'array':
97			$arr = (array) $data[$value['attr']];
98			unset($arr['count']);
99			$attrs[$attr] = $arr;
100
101			break;
102			case 'string':
103			$attrs[$attr] = (string) $store;
104
105			break;
106			case 'int':
107			$attrs[$attr] = (int) $store;
108
109			break;
110			case 'bool':
111			$attrs[$attr] = (bool) $store;
112
113			break;
114			default:
115			$this->logger->error('unknown attribute type ['.$value['type'].'] for attribute ['.$attr.']; use one of [array,string,int,bool]', [
116			'category' => get_class($this),
117			]);
118
119			break;
120			}
121			} else {
122			$this->logger->warning('auth attribute ['.$value['attr'].'] was not found from authentication adapter response', [
123			'category' => get_class($this),
124			]);
125			}
126			}
127
128			return $attrs;
129			}
130			}
131

gyselroth / micro-auth

AttributeMap::map() B last analyzed 2019-04-12 14:15 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

AttributeMap::map() B
last analyzed 2019-04-12 14:15 UTC