ClientFactory::newClient() - Code Metrics - Inspection of "add option for no starttls at all" - genkgo/mail - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 6d3e15...682097 )

by Frederik

created 2020-09-03 18:24 UTC

ClientFactory::newClient() A

↳ Parent: ClientFactory

Complexity

Conditions	4
Paths	6

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	18
CRAP Score	4.0961

Importance

Changes

Metric	Value
dl	0
loc	37
ccs	18
cts	22
cp	0.8182
rs	9.328
c	0
b	0
f	0
cc	4
nc	6
nop	0
crap	4.0961

<?php
declare(strict_types=1);

namespace Genkgo\Mail\Protocol\Smtp;

use Genkgo\Mail\Protocol\AutomaticConnection;
use Genkgo\Mail\Protocol\ConnectionInterface;
use Genkgo\Mail\Protocol\CryptoConstant;
use Genkgo\Mail\Protocol\PlainTcpConnection;
use Genkgo\Mail\Protocol\SecureConnection;
use Genkgo\Mail\Protocol\SecureConnectionOptions;
use Genkgo\Mail\Protocol\Smtp\Negotiation\AuthNegotiation;
use Genkgo\Mail\Protocol\Smtp\Negotiation\ForceTlsUpgradeNegotiation;
use Genkgo\Mail\Protocol\Smtp\Negotiation\TryTlsUpgradeNegotiation;

final class ClientFactory
{
    private const AUTH_ENUM = [Client::AUTH_NONE, Client::AUTH_PLAIN, Client::AUTH_LOGIN, Client::AUTH_AUTO];

    /**
     * @var ConnectionInterface
     */
    private $connection;

    /**
     * @var string
     */
    private $password = '';

    /**
     * @var float
     */
    private $timeout = 1;

    /**
     * @var string
     */
    private $username = '';

    /**
     * @var string
     */
    private $ehlo = '127.0.0.1';

    /**
     * @var int
     */
    private $authMethod = Client::AUTH_NONE;

    /**
     * @var bool
     */
    private $insecureConnectionAllowed = false;

    /**
     * @var string
     */
    private $reconnectAfter = 'PT300S';

    /**
     * @var int
     */
    private $startTls;

    /**
     * @param ConnectionInterface $connection
     */
    public function __construct(ConnectionInterface $connection)
    {
        $this->connection = $connection;
        $this->startTls = CryptoConstant::getDefaultMethod(PHP_VERSION);
    }

    /**
     * @param float $connectionTimeout
     * @return ClientFactory
     */
    public function withTimeout(float $connectionTimeout): ClientFactory
    {
        $clone = clone $this;
        $clone->timeout = $connectionTimeout;
        return $clone;
    }

    /**
     * @param int $method
     * @param string $password
     * @param string $username
     * @return ClientFactory
     */
    public function withAuthentication(int $method, string $username, string $password): ClientFactory
    {
        if (!\in_array($method, self::AUTH_ENUM)) {
            throw new \InvalidArgumentException('Invalid authentication method');
        }

        $clone = clone $this;
        $clone->authMethod = $method;
        $clone->username = $username;
        $clone->password = $password;
        return $clone;
    }

    /**
     * @param string $ehlo
     * @return ClientFactory
     */
    public function withEhlo(string $ehlo): ClientFactory
    {
        $clone = clone $this;
        $clone->ehlo = $ehlo;
        return $clone;
    }

    /**
     * @return ClientFactory
     */
    public function withInsecureConnectionAllowed(): ClientFactory
    {
        $clone = clone $this;
        $clone->insecureConnectionAllowed = true;
        return $clone;
    }

    /**
     * @param int $crypto
     * @return ClientFactory
     */
    public function withStartTls(int $crypto): ClientFactory
    {
        $clone = clone $this;
        $clone->startTls = $crypto;
        return $clone;
    }

    /**
     * @return ClientFactory
     */
    public function withoutStartTls(): ClientFactory
    {
        $clone = clone $this;
        $clone->startTls = 0;
        return $clone;
    }

    /**
     * @return Client
     */
    public function newClient(): Client
    {
        $negotiators = [];

        if ($this->startTls !== 0) {
            if ($this->insecureConnectionAllowed) {
                $negotiators[] = new TryTlsUpgradeNegotiation(
                    $this->connection,
                    $this->ehlo,
                    $this->startTls
                );
            } else {
                $negotiators[] = new ForceTlsUpgradeNegotiation(
                    $this->connection,
                    $this->ehlo,
                    $this->startTls
                );
            }
        }

        if ($this->authMethod !== Client::AUTH_NONE) {
            $negotiators[] = new AuthNegotiation(
                $this->ehlo,
                $this->authMethod,
                $this->username,
                $this->password
            );
        }

        return new Client(
            new AutomaticConnection(
                $this->connection,
                new \DateInterval($this->reconnectAfter)
            ),
            $negotiators
        );
    }

    /**
     * @param string $dataSourceName
     * @return ClientFactory
     */
    public static function fromString(string $dataSourceName):ClientFactory
    {
        $components = \parse_url($dataSourceName);
        if ($components === false || !isset($components['scheme']) || !isset($components['host'])) {
            throw new \InvalidArgumentException('Scheme and host are required');
        }

        if (isset($components['query'])) {
            \parse_str($components['query'], $query);
        } else {
            $query = [];
        }

        $insecureConnectionAllowed = false;
        $startTls = true;
        switch ($components['scheme']) {
            case 'smtp':
                $connection = new PlainTcpConnection(
                    $components['host'],
                    $components['port'] ?? 587
                );
                break;
            case 'smtps':
                $connection = new SecureConnection(
                    $components['host'],
                    $components['port'] ?? 465,
                    new SecureConnectionOptions(
                        (int)($query['crypto'] ?? CryptoConstant::getDefaultMethod(PHP_VERSION))
                    )
                );
                break;
            case 'smtp-starttls':
                $insecureConnectionAllowed = true;
                $startTls = false;

                $connection = new PlainTcpConnection(
                    $components['host'],
                    $components['port'] ?? 25
                );
                break;
            case 'smtp+starttls':
                $insecureConnectionAllowed = true;
                $startTls = true;

                $connection = new PlainTcpConnection(
                    $components['host'],
                    $components['port'] ?? 25
                );
                break;
            default:
                throw new \InvalidArgumentException(\sprintf(
                    'Provided scheme "%s://" is invalid. Only smtp:// smtps:// and smtp-starttls:// are supported',
                    $components['scheme']
                ));
        }

        $factory = new self($connection);
        $factory->insecureConnectionAllowed = $insecureConnectionAllowed;

        if (isset($components['user'], $components['pass'])) {
            $factory->authMethod = Client::AUTH_AUTO;
            $factory->username = \urldecode($components['user']);
            $factory->password = \urldecode($components['pass']);
        }

        if (isset($query['ehlo'])) {
            $factory->ehlo = $query['ehlo'];
        }

        if (isset($query['timeout'])) {
            $factory->timeout = (float)$query['timeout'];
        }

        if (isset($query['reconnectAfter'])) {
            $factory->reconnectAfter = $query['reconnectAfter'];
        }

        if (!$startTls) {
            $factory->startTls = 0;
        } elseif (isset($query['crypto'])) {
            $factory->startTls = (int)$query['crypto'];
        }

        return $factory;
    }
}


1		<?php
2		declare(strict_types=1);
3
4		namespace Genkgo\Mail\Protocol\Smtp;
5
6		use Genkgo\Mail\Protocol\AutomaticConnection;
7		use Genkgo\Mail\Protocol\ConnectionInterface;
8		use Genkgo\Mail\Protocol\CryptoConstant;
9		use Genkgo\Mail\Protocol\PlainTcpConnection;
10		use Genkgo\Mail\Protocol\SecureConnection;
11		use Genkgo\Mail\Protocol\SecureConnectionOptions;
12		use Genkgo\Mail\Protocol\Smtp\Negotiation\AuthNegotiation;
13		use Genkgo\Mail\Protocol\Smtp\Negotiation\ForceTlsUpgradeNegotiation;
14		use Genkgo\Mail\Protocol\Smtp\Negotiation\TryTlsUpgradeNegotiation;
15
16		final class ClientFactory
17		{
18		private const AUTH_ENUM = [Client::AUTH_NONE, Client::AUTH_PLAIN, Client::AUTH_LOGIN, Client::AUTH_AUTO];
19
20		/**
21		* @var ConnectionInterface
22		*/
23		private $connection;
24
25		/**
26		* @var string
27		*/
28		private $password = '';
29
30		/**
31		* @var float
32		*/
33		private $timeout = 1;
34
35		/**
36		* @var string
37		*/
38		private $username = '';
39
40		/**
41		* @var string
42		*/
43		private $ehlo = '127.0.0.1';
44
45		/**
46		* @var int
47		*/
48		private $authMethod = Client::AUTH_NONE;
49
50		/**
51		* @var bool
52		*/
53		private $insecureConnectionAllowed = false;
54
55		/**
56		* @var string
57		*/
58		private $reconnectAfter = 'PT300S';
59
60		/**
61		* @var int
62		*/
63		private $startTls;
64
65		/**
66		* @param ConnectionInterface $connection
67		*/
68	9	public function __construct(ConnectionInterface $connection)
69		{
70	9	$this->connection = $connection;
71	9	$this->startTls = CryptoConstant::getDefaultMethod(PHP_VERSION);
72	9	}
73
74		/**
75		* @param float $connectionTimeout
76		* @return ClientFactory
77		*/
78	1	public function withTimeout(float $connectionTimeout): ClientFactory
79		{
80	1	$clone = clone $this;
81	1	$clone->timeout = $connectionTimeout;
82	1	return $clone;
83		}
84
85		/**
86		* @param int $method
87		* @param string $password
88		* @param string $username
89		* @return ClientFactory
90		*/
91	3	public function withAuthentication(int $method, string $username, string $password): ClientFactory
92		{
93	3	if (!\in_array($method, self::AUTH_ENUM)) {
94	1	throw new \InvalidArgumentException('Invalid authentication method');
95		}
96
97	2	$clone = clone $this;
98	2	$clone->authMethod = $method;
99	2	$clone->username = $username;
100	2	$clone->password = $password;
101	2	return $clone;
102		}
103
104		/**
105		* @param string $ehlo
106		* @return ClientFactory
107		*/
108	4	public function withEhlo(string $ehlo): ClientFactory
109		{
110	4	$clone = clone $this;
111	4	$clone->ehlo = $ehlo;
112	4	return $clone;
113		}
114
115		/**
116		* @return ClientFactory
117		*/
118	2	public function withInsecureConnectionAllowed(): ClientFactory
119		{
120	2	$clone = clone $this;
121	2	$clone->insecureConnectionAllowed = true;
122	2	return $clone;
123		}
124
125		/**
126		* @param int $crypto
127		* @return ClientFactory
128		*/
129	1	public function withStartTls(int $crypto): ClientFactory
130		{
131	1	$clone = clone $this;
132	1	$clone->startTls = $crypto;
133	1	return $clone;
134		}
135
136		/**
137		* @return ClientFactory
138		*/
139	1	public function withoutStartTls(): ClientFactory
140		{
141	1	$clone = clone $this;
142	1	$clone->startTls = 0;
143	1	return $clone;
144		}
145
146		/**
147		* @return Client
148		*/
149	7	public function newClient(): Client
150		{
151	7	$negotiators = [];
152
153	7	if ($this->startTls !== 0) {
154	5	if ($this->insecureConnectionAllowed) {
155		$negotiators[] = new TryTlsUpgradeNegotiation(
156		$this->connection,
157		$this->ehlo,
158		$this->startTls
159		);
160		} else {
161	5	$negotiators[] = new ForceTlsUpgradeNegotiation(
162	5	$this->connection,
163	5	$this->ehlo,
164	5	$this->startTls
165		);
166		}
167		}
168
169	7	if ($this->authMethod !== Client::AUTH_NONE) {
170	2	$negotiators[] = new AuthNegotiation(
171	2	$this->ehlo,
172	2	$this->authMethod,
173	2	$this->username,
174	2	$this->password
175		);
176		}
177
178	7	return new Client(
179	7	new AutomaticConnection(
180	7	$this->connection,
181	7	new \DateInterval($this->reconnectAfter)
182		),
183		$negotiators
184		);
185		}
186
187		/**
188		* @param string $dataSourceName
189		* @return ClientFactory
190		*/
191	6	public static function fromString(string $dataSourceName):ClientFactory
192		{
193	6	$components = \parse_url($dataSourceName);
194	6	if ($components === false \|\| !isset($components['scheme']) \|\| !isset($components['host'])) {
195	1	throw new \InvalidArgumentException('Scheme and host are required');
196		}
197
198	5	if (isset($components['query'])) {
199	2	\parse_str($components['query'], $query);
200		} else {
201	3	$query = [];
202		}
203
204	5	$insecureConnectionAllowed = false;
205	5	$startTls = true;
206	5	switch ($components['scheme']) {
207	5	case 'smtp':
208	1	$connection = new PlainTcpConnection(
209	1	$components['host'],
210	1	$components['port'] ?? 587
211		);
212	1	break;
213	4	case 'smtps':
214	2	$connection = new SecureConnection(
215	2	$components['host'],
216	2	$components['port'] ?? 465,
217	2	new SecureConnectionOptions(
218	2	(int)($query['crypto'] ?? CryptoConstant::getDefaultMethod(PHP_VERSION))
219		)
220		);
221	2	break;
222	2	case 'smtp-starttls':
223	1	$insecureConnectionAllowed = true;
224	1	$startTls = false;
225
226	1	$connection = new PlainTcpConnection(
227	1	$components['host'],
228	1	$components['port'] ?? 25
229		);
230	1	break;
231	1	case 'smtp+starttls':
232		$insecureConnectionAllowed = true;
233		$startTls = true;
234
235		$connection = new PlainTcpConnection(
236		$components['host'],
237		$components['port'] ?? 25
238		);
239		break;
240		default:
241	1	throw new \InvalidArgumentException(\sprintf(
242	1	'Provided scheme "%s://" is invalid. Only smtp:// smtps:// and smtp-starttls:// are supported',
243	1	$components['scheme']
244		));
245		}
246
247	4	$factory = new self($connection);
248	4	$factory->insecureConnectionAllowed = $insecureConnectionAllowed;
249
250	4	if (isset($components['user'], $components['pass'])) {
251	1	$factory->authMethod = Client::AUTH_AUTO;
252	1	$factory->username = \urldecode($components['user']);
253	1	$factory->password = \urldecode($components['pass']);
254		}
255
256	4	if (isset($query['ehlo'])) {
257	1	$factory->ehlo = $query['ehlo'];
258		}
259
260	4	if (isset($query['timeout'])) {
261	1	$factory->timeout = (float)$query['timeout'];
262		}
263
264	4	if (isset($query['reconnectAfter'])) {
265	1	$factory->reconnectAfter = $query['reconnectAfter'];
266		}
267
268	4	if (!$startTls) {
269	1	$factory->startTls = 0;
270	3	} elseif (isset($query['crypto'])) {
271	1	$factory->startTls = (int)$query['crypto'];
272		}
273
274	4	return $factory;
275		}
276		}
277

genkgo / mail

Push — master ( 6d3e15...682097 )

ClientFactory::newClient() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like