PasswordGenerator::getFromTopology() - Code Metrics - Inspection of "mongodb pecl removed" - linna/framework - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 8bc73a...1a3e6a )

by Sebastian

created 2018-01-11 19:52 UTC

PasswordGenerator::getFromTopology() A

↳ Parent: PasswordGenerator

Complexity

Conditions	3
Paths	3

Size

Total Lines	20
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	11
CRAP Score	3

Importance

Changes

Metric	Value
dl	0
loc	20
ccs	11
cts	11
cp	1
rs	9.4285
c	0
b	0
f	0
cc	3
eloc	11
nc	3
nop	1
crap	3

<?php

/**
 * Linna Framework.
 *
 * @author Sebastian Rapetti <[email protected]>
 * @copyright (c) 2018, Sebastian Rapetti
 * @license http://opensource.org/licenses/MIT MIT License
 */
declare(strict_types=1);

namespace Linna\Authentication;

use InvalidArgumentException;

/**
 * Generate random password with random topology, this class use php7
 * random_int() function for generate random numbers.
 */
class PasswordGenerator
{
    /**
     * @var array Characters intervall utf8 dec rappresentation
     */
    private $chars = [
        [[65, 90]], //u 117
        [[97, 122]], //l 108
        [[48, 57]], //d 100
        [[33, 47], [58, 64], [91, 96], [123, 126]], //s 115
    ];

    /**
     * Generate a random password.
     * <pre><code class="php">use Linna\Auth\PasswordGenerator;
     *
     * $passwordGenerator = new PasswordGenerator();
     * $random = $passwordGenerator->getFromRandom(20);
     *
     * //var_dump result
     * //r4Q,1J*tM7D_99q0u>61
     * var_dump($random);
     * </code></pre>
     *
     * @param int $length Desiderated password length.
     * @return string Random password.
     */
    public function getFromRandom(int $length): string
    {
        $password = [];

        while ($length) {
            $password[] = $this->getRandomChar($this->chars[random_int(0, 3)]);
            
            $length--;
        }
        
        return implode($password);
    }

    /**
     * Return topology for given password.
     * <pre><code class="php">use Linna\Auth\PasswordGenerator;
     *
     * $passwordGenerator = new PasswordGenerator();
     * $topology = $passwordGenerator->getTopology('r4Q,1J*tM7D_99q0u>61');
     *
     * //var_dump result
     * //ldusdusludusddldlsdd
     * var_dump($topology);
     * </code></pre>
     * @param string $password Password.
     *
     * @return string Topology for the argument passed password.
     */
    public function getTopology(string $password): string
    {
        $array = str_split($password);
        $topology = [];
        
        foreach ($array as $char) {
            $topology[] = $this->getTopologyGroup($char);
        }

        return implode($topology);
    }

    /**
     * Return topology group for the given char.
     *
     * @param string $char
     *
     * @return string
     */
    private function getTopologyGroup(string $char) : string
    {
        $int = ord($char);
        $groups = ['u', 'l', 'd', 's'];
        
        foreach ($groups as $key => $group) {
            if ($this->inRanges($int, $this->chars[$key])) {
                return $group;
            }
        }
    }
    
    /**
     * Generate a random password corresponding at the given topology.
     * <pre><code class="php">use Linna\Auth\PasswordGenerator;
     *
     * $passwordGenerator = new PasswordGenerator();
     * $random = $passwordGenerator->getFromTopology('ldusdusludusddldlsdd');
     *
     * //var_dump result
     * //r4Q,1J*tM7D_99q0u>61
     * var_dump($random);
     * </code></pre>
     *
     * @param string $topology Topology for generate password.
     * @return string Random password corresponding the given topology.
     *
     * @throws InvalidArgumentException If invalid pattern is provided.
     */
    public function getFromTopology(string $topology): string
    {
        $array = str_split(strtolower($topology));
        $groups = [117 => 0, 108 => 1, 100 => 2, 115 => 3];
        $password = [];

        foreach ($array as $char) {
            $int = ord($char);

            if (isset($groups[$int])) {
                $password[] = $this->getRandomChar($this->chars[$groups[$int]]);

                continue;
            }

            throw new InvalidArgumentException('Invalid pattern provided, accepted only u, l, d and s');
        }

        return implode($password);
    }

    /**
     * Get random char between.
     *
     * @param array $interval
     * @return string
     */
    private function getRandomChar(array $interval): string
    {
        do {
            $int = random_int(33, 122);
            if ($this->inRanges($int, $interval)) {
                break;
            }
        } while (true);
            
        return chr($int);
    }

    /**
     * Check if value is between given range.
     *
     * @param mixed $value
     * @param array $ranges
     *
     * @return bool
     */
    private function inRanges($value, array $ranges): bool
    {
        foreach ($ranges as $range) {
            if ($value >= $range[0] && $value <= $range[1]) {
                return true;
            }
        }

        return false;
    }
}


1		<?php
2
3		/**
4		* Linna Framework.
5		*
6		* @author Sebastian Rapetti <[email protected]>
7		* @copyright (c) 2018, Sebastian Rapetti
8		* @license http://opensource.org/licenses/MIT MIT License
9		*/
10		declare(strict_types=1);
11
12		namespace Linna\Authentication;
13
14		use InvalidArgumentException;
15
16		/**
17		* Generate random password with random topology, this class use php7
18		* random_int() function for generate random numbers.
19		*/
20		class PasswordGenerator
21		{
22		/**
23		* @var array Characters intervall utf8 dec rappresentation
24		*/
25		private $chars = [
26		[[65, 90]], //u 117
27		[[97, 122]], //l 108
28		[[48, 57]], //d 100
29		[[33, 47], [58, 64], [91, 96], [123, 126]], //s 115
30		];
31
32		/**
33		* Generate a random password.
34		* <pre><code class="php">use Linna\Auth\PasswordGenerator;
35		*
36		* $passwordGenerator = new PasswordGenerator();
37		* $random = $passwordGenerator->getFromRandom(20);
38		*
39		* //var_dump result
40		* //r4Q,1J*tM7D_99q0u>61
41		* var_dump($random);
42		* </code></pre>
43		*
44		* @param int $length Desiderated password length.
45		* @return string Random password.
46		*/
47	8	public function getFromRandom(int $length): string
48		{
49	8	$password = [];
50
51	8	while ($length) {
52	8	$password[] = $this->getRandomChar($this->chars[random_int(0, 3)]);
53
54	8	$length--;
55		}
56
57	8	return implode($password);
58		}
59
60		/**
61		* Return topology for given password.
62		* <pre><code class="php">use Linna\Auth\PasswordGenerator;
63		*
64		* $passwordGenerator = new PasswordGenerator();
65		* $topology = $passwordGenerator->getTopology('r4Q,1J*tM7D_99q0u>61');
66		*
67		* //var_dump result
68		* //ldusdusludusddldlsdd
69		* var_dump($topology);
70		* </code></pre>
71		* @param string $password Password.
72		*
73		* @return string Topology for the argument passed password.
74		*/
75	25	public function getTopology(string $password): string
76		{
77	25	$array = str_split($password);
78	25	$topology = [];
79
80	25	foreach ($array as $char) {
81	25	$topology[] = $this->getTopologyGroup($char);
82		}
83
84	25	return implode($topology);
85		}
86
87		/**
88		* Return topology group for the given char.
89		*
90		* @param string $char
91		*
92		* @return string
93		*/
94	25	private function getTopologyGroup(string $char) : string
95		{
96	25	$int = ord($char);
97	25	$groups = ['u', 'l', 'd', 's'];
98
99	25	foreach ($groups as $key => $group) {
100	25	if ($this->inRanges($int, $this->chars[$key])) {
101	25	return $group;
102		}
103		}
104		}
105
106		/**
107		* Generate a random password corresponding at the given topology.
108		* <pre><code class="php">use Linna\Auth\PasswordGenerator;
109		*
110		* $passwordGenerator = new PasswordGenerator();
111		* $random = $passwordGenerator->getFromTopology('ldusdusludusddldlsdd');
112		*
113		* //var_dump result
114		* //r4Q,1J*tM7D_99q0u>61
115		* var_dump($random);
116		* </code></pre>
117		*
118		* @param string $topology Topology for generate password.
119		* @return string Random password corresponding the given topology.
120		*
121		* @throws InvalidArgumentException If invalid pattern is provided.
122		*/
123	16	public function getFromTopology(string $topology): string
124		{
125	16	$array = str_split(strtolower($topology));
126	16	$groups = [117 => 0, 108 => 1, 100 => 2, 115 => 3];
127	16	$password = [];
128
129	16	foreach ($array as $char) {
130	16	$int = ord($char);
131
132	16	if (isset($groups[$int])) {
133	13	$password[] = $this->getRandomChar($this->chars[$groups[$int]]);
134
135	13	continue;
136		}
137
138	6	throw new InvalidArgumentException('Invalid pattern provided, accepted only u, l, d and s');
139		}
140
141	10	return implode($password);
142		}
143
144		/**
145		* Get random char between.
146		*
147		* @param array $interval
148		* @return string
149		*/
150	21	private function getRandomChar(array $interval): string
151		{
152		do {
153	21	$int = random_int(33, 122);
154	21	if ($this->inRanges($int, $interval)) {
155	21	break;
156		}
157	21	} while (true);
158
159	21	return chr($int);
160		}
161
162		/**
163		* Check if value is between given range.
164		*
165		* @param mixed $value
166		* @param array $ranges
167		*
168		* @return bool
169		*/
170	32	private function inRanges($value, array $ranges): bool
171		{
172	32	foreach ($ranges as $range) {
173	32	if ($value >= $range[0] && $value <= $range[1]) {
174	32	return true;
175		}
176		}
177
178	32	return false;
179		}
180		}
181

linna / framework

Push — master ( 8bc73a...1a3e6a )

PasswordGenerator::getFromTopology() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like