SetCookie::createExpired() - Code Metrics - Inspection of "Merge pull request #45 from franzliedke/fl/23-depr..." - dflydev/dflydev-fig-cookies - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — main ( f06d77...6ba089 )

by Beau

created 2021-04-30 14:51 UTC

SetCookie::createExpired() A

↳ Parent: SetCookie

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	0
cts	2
cp	0
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1
crap	2

<?php

declare(strict_types=1);

namespace Dflydev\FigCookies;

use DateTime;
use DateTimeInterface;
use Dflydev\FigCookies\Modifier\SameSite;
use InvalidArgumentException;

use function array_shift;
use function count;
use function explode;
use function gmdate;
use function implode;
use function is_int;
use function is_numeric;
use function is_string;
use function sprintf;
use function strtolower;
use function strtotime;
use function urlencode;

class SetCookie
{
    /** @var string */
    private $name;
    /** @var string|null */
    private $value;
    /** @var int */
    private $expires = 0;
    /** @var int */
    private $maxAge = 0;
    /** @var string|null */
    private $path;
    /** @var string|null */
    private $domain;
    /** @var bool */
    private $secure = false;
    /** @var bool */
    private $httpOnly = false;
    /** @var SameSite|null */
    private $sameSite;

    private function __construct(string $name, ?string $value = null)
    {
        $this->name  = $name;
        $this->value = $value;
    }

    public function getName(): string
    {
        return $this->name;
    }

    public function getValue(): ?string
    {
        return $this->value;
    }

    public function getExpires(): int
    {
        return $this->expires;
    }

    public function getMaxAge(): int
    {
        return $this->maxAge;
    }

    public function getPath(): ?string
    {
        return $this->path;
    }

    public function getDomain(): ?string
    {
        return $this->domain;
    }

    public function getSecure(): bool
    {
        return $this->secure;
    }

    public function getHttpOnly(): bool
    {
        return $this->httpOnly;
    }

    public function getSameSite(): ?SameSite
    {
        return $this->sameSite;
    }

    public function withValue(?string $value = null): self
    {
        $clone = clone $this;

        $clone->value = $value;

        return $clone;
    }

    /** @param int|DateTimeInterface|string|null $expires */
    private function resolveExpires($expires = null): int
    {
        if ($expires === null) {
            return 0;
        }

        if ($expires instanceof DateTimeInterface) {
            return (int) $expires->getTimestamp();
        }

        if (is_numeric($expires)) {
            return (int) $expires;
        }

        $time = strtotime($expires);

        if (! is_int($time)) {
            throw new InvalidArgumentException(sprintf('Invalid expires "%s" provided', $expires));
        }

        return $time;
    }

    /** @param int|string|DateTimeInterface|null $expires */
    public function withExpires($expires = null): self
    {
        $expires = $this->resolveExpires($expires);

        $clone = clone $this;

        $clone->expires = $expires;

        return $clone;
    }

    public function rememberForever(): self
    {
        return $this->withExpires(new DateTime('+5 years'));
    }

    public function expire(): self
    {
        return $this->withExpires(new DateTime('-5 years'));
    }

    public function withMaxAge(?int $maxAge = null): self
    {
        $clone = clone $this;

        $clone->maxAge = (int) $maxAge;

        return $clone;
    }

    public function withPath(?string $path = null): self
    {
        $clone = clone $this;

        $clone->path = $path;

        return $clone;
    }

    public function withDomain(?string $domain = null): self
    {
        $clone = clone $this;

        $clone->domain = $domain;

        return $clone;
    }

    public function withSecure(bool $secure = true): self
    {
        $clone = clone $this;

        $clone->secure = $secure;

        return $clone;
    }

    public function withHttpOnly(bool $httpOnly = true): self
    {
        $clone = clone $this;

        $clone->httpOnly = $httpOnly;

        return $clone;
    }

    public function withSameSite(SameSite $sameSite): self
    {
        $clone = clone $this;

        $clone->sameSite = $sameSite;

        return $clone;
    }

    public function withoutSameSite(): self
    {
        $clone = clone $this;

        $clone->sameSite = null;

        return $clone;
    }

    public function __toString(): string
    {
        $cookieStringParts = [
            urlencode($this->name) . '=' . urlencode((string) $this->value),
        ];

        $cookieStringParts = $this->appendFormattedDomainPartIfSet($cookieStringParts);
        $cookieStringParts = $this->appendFormattedPathPartIfSet($cookieStringParts);
        $cookieStringParts = $this->appendFormattedExpiresPartIfSet($cookieStringParts);
        $cookieStringParts = $this->appendFormattedMaxAgePartIfSet($cookieStringParts);
        $cookieStringParts = $this->appendFormattedSecurePartIfSet($cookieStringParts);
        $cookieStringParts = $this->appendFormattedHttpOnlyPartIfSet($cookieStringParts);
        $cookieStringParts = $this->appendFormattedSameSitePartIfSet($cookieStringParts);

        return implode('; ', $cookieStringParts);
    }

    public static function create(string $name, ?string $value = null): self
    {
        return new static($name, $value);
    }

    public static function createRememberedForever(string $name, ?string $value = null): self
    {
        return static::create($name, $value)->rememberForever();
    }

    /**
     * @deprecated Do not use this method. Will be removed in v4.0.
     *
     * If you want to remove a cookie, create it normally and call ->expire()
     * on the SetCookie object.
     */
    public static function createExpired(string $name): self
    {
        return static::create($name)->expire();
    }

    public static function fromSetCookieString(string $string): self
    {
        $rawAttributes = StringUtil::splitOnAttributeDelimiter($string);

        $rawAttribute = array_shift($rawAttributes);

        if (! is_string($rawAttribute)) {
            throw new InvalidArgumentException(sprintf(
                'The provided cookie string "%s" must have at least one attribute',
                $string
            ));
        }

        [$cookieName, $cookieValue] = StringUtil::splitCookiePair($rawAttribute);


        $setCookie = new static($cookieName);

        if ($cookieValue !== null) {
            $setCookie = $setCookie->withValue($cookieValue);
        }

        while ($rawAttribute = array_shift($rawAttributes)) {
            $rawAttributePair = explode('=', $rawAttribute, 2);

            $attributeKey   = $rawAttributePair[0];
            $attributeValue = count($rawAttributePair) > 1 ? $rawAttributePair[1] : null;

            $attributeKey = strtolower($attributeKey);

            switch ($attributeKey) {
                case 'expires':
                    $setCookie = $setCookie->withExpires($attributeValue);
                    break;
                case 'max-age':
                    $setCookie = $setCookie->withMaxAge((int) $attributeValue);
                    break;
                case 'domain':
                    $setCookie = $setCookie->withDomain($attributeValue);
                    break;
                case 'path':
                    $setCookie = $setCookie->withPath($attributeValue);
                    break;
                case 'secure':
                    $setCookie = $setCookie->withSecure(true);
                    break;
                case 'httponly':
                    $setCookie = $setCookie->withHttpOnly(true);
                    break;
                case 'samesite':
                    $setCookie = $setCookie->withSameSite(SameSite::fromString((string) $attributeValue));
                    break;
            }
        }

        return $setCookie;
    }

    /**
     * @param string[] $cookieStringParts
     *
     * @return string[]
     */
    private function appendFormattedDomainPartIfSet(array $cookieStringParts): array
    {
        if ($this->domain) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $cookieStringParts[] = sprintf('Domain=%s', $this->domain);
        }

        return $cookieStringParts;
    }

    /**
     * @param string[] $cookieStringParts
     *
     * @return string[]
     */
    private function appendFormattedPathPartIfSet(array $cookieStringParts): array
    {
        if ($this->path) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $cookieStringParts[] = sprintf('Path=%s', $this->path);
        }

        return $cookieStringParts;
    }

    /**
     * @param string[] $cookieStringParts
     *
     * @return string[]
     */
    private function appendFormattedExpiresPartIfSet(array $cookieStringParts): array
    {
        if ($this->expires) {
            $cookieStringParts[] = sprintf('Expires=%s', gmdate('D, d M Y H:i:s T', $this->expires));
        }

        return $cookieStringParts;
    }

    /**
     * @param string[] $cookieStringParts
     *
     * @return string[]
     */
    private function appendFormattedMaxAgePartIfSet(array $cookieStringParts): array
    {
        if ($this->maxAge) {
            $cookieStringParts[] = sprintf('Max-Age=%s', $this->maxAge);
        }

        return $cookieStringParts;
    }

    /**
     * @param string[] $cookieStringParts
     *
     * @return string[]
     */
    private function appendFormattedSecurePartIfSet(array $cookieStringParts): array
    {
        if ($this->secure) {
            $cookieStringParts[] = 'Secure';
        }

        return $cookieStringParts;
    }

    /**
     * @param string[] $cookieStringParts
     *
     * @return string[]
     */
    private function appendFormattedHttpOnlyPartIfSet(array $cookieStringParts): array
    {
        if ($this->httpOnly) {
            $cookieStringParts[] = 'HttpOnly';
        }

        return $cookieStringParts;
    }

    /**
     * @param string[] $cookieStringParts
     *
     * @return string[]
     */
    private function appendFormattedSameSitePartIfSet(array $cookieStringParts): array
    {
        if ($this->sameSite === null) {
            return $cookieStringParts;
        }

        $cookieStringParts[] = $this->sameSite->asString();

        return $cookieStringParts;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Dflydev\FigCookies;
6
7		use DateTime;
8		use DateTimeInterface;
9		use Dflydev\FigCookies\Modifier\SameSite;
10		use InvalidArgumentException;
11
12		use function array_shift;
13		use function count;
14		use function explode;
15		use function gmdate;
16		use function implode;
17		use function is_int;
18		use function is_numeric;
19		use function is_string;
20		use function sprintf;
21		use function strtolower;
22		use function strtotime;
23		use function urlencode;
24
25		class SetCookie
26		{
27		/** @var string */
28		private $name;
29		/** @var string\|null */
30		private $value;
31		/** @var int */
32		private $expires = 0;
33		/** @var int */
34		private $maxAge = 0;
35		/** @var string\|null */
36		private $path;
37		/** @var string\|null */
38		private $domain;
39		/** @var bool */
40		private $secure = false;
41		/** @var bool */
42		private $httpOnly = false;
43		/** @var SameSite\|null */
44		private $sameSite;
45
46	35	private function __construct(string $name, ?string $value = null)
47		{
48	35	$this->name = $name;
49	35	$this->value = $value;
50	35	}
51
52	19	public function getName(): string
53		{
54	19	return $this->name;
55		}
56
57	3	public function getValue(): ?string
58		{
59	3	return $this->value;
60		}
61
62	2	public function getExpires(): int
63		{
64	2	return $this->expires;
65		}
66
67		public function getMaxAge(): int
68		{
69		return $this->maxAge;
70		}
71
72		public function getPath(): ?string
73		{
74		return $this->path;
75		}
76
77		public function getDomain(): ?string
78		{
79		return $this->domain;
80		}
81
82		public function getSecure(): bool
83		{
84		return $this->secure;
85		}
86
87		public function getHttpOnly(): bool
88		{
89		return $this->httpOnly;
90		}
91
92	1	public function getSameSite(): ?SameSite
93		{
94	1	return $this->sameSite;
95		}
96
97	32	public function withValue(?string $value = null): self
98		{
99	32	$clone = clone $this;
100
101	32	$clone->value = $value;
102
103	32	return $clone;
104		}
105
106		/** @param int\|DateTimeInterface\|string\|null $expires */
107	16	private function resolveExpires($expires = null): int
108		{
109	16	if ($expires === null) {
110		return 0;
111		}
112
113	16	if ($expires instanceof DateTimeInterface) {
114	2	return (int) $expires->getTimestamp();
115		}
116
117	14	if (is_numeric($expires)) {
118		return (int) $expires;
119		}
120
121	14	$time = strtotime($expires);
122
123	14	if (! is_int($time)) {
124	1	throw new InvalidArgumentException(sprintf('Invalid expires "%s" provided', $expires));
125		}
126
127	13	return $time;
128		}
129
130		/** @param int\|string\|DateTimeInterface\|null $expires */
131	16	public function withExpires($expires = null): self
132		{
133	16	$expires = $this->resolveExpires($expires);
134
135	15	$clone = clone $this;
136
137	15	$clone->expires = $expires;
138
139	15	return $clone;
140		}
141
142	1	public function rememberForever(): self
143		{
144	1	return $this->withExpires(new DateTime('+5 years'));
145		}
146
147	1	public function expire(): self
148		{
149	1	return $this->withExpires(new DateTime('-5 years'));
150		}
151
152	6	public function withMaxAge(?int $maxAge = null): self
153		{
154	6	$clone = clone $this;
155
156	6	$clone->maxAge = (int) $maxAge;
157
158	6	return $clone;
159		}
160
161	15	public function withPath(?string $path = null): self
162		{
163	15	$clone = clone $this;
164
165	15	$clone->path = $path;
166
167	15	return $clone;
168		}
169
170	10	public function withDomain(?string $domain = null): self
171		{
172	10	$clone = clone $this;
173
174	10	$clone->domain = $domain;
175
176	10	return $clone;
177		}
178
179	12	public function withSecure(bool $secure = true): self
180		{
181	12	$clone = clone $this;
182
183	12	$clone->secure = $secure;
184
185	12	return $clone;
186		}
187
188	15	public function withHttpOnly(bool $httpOnly = true): self
189		{
190	15	$clone = clone $this;
191
192	15	$clone->httpOnly = $httpOnly;
193
194	15	return $clone;
195		}
196
197	3	public function withSameSite(SameSite $sameSite): self
198		{
199	3	$clone = clone $this;
200
201	3	$clone->sameSite = $sameSite;
202
203	3	return $clone;
204		}
205
206	1	public function withoutSameSite(): self
207		{
208	1	$clone = clone $this;
209
210	1	$clone->sameSite = null;
211
212	1	return $clone;
213		}
214
215	20	public function __toString(): string
216		{
217	20	$cookieStringParts = [
218	20	urlencode($this->name) . '=' . urlencode((string) $this->value),
219		];
220
221	20	$cookieStringParts = $this->appendFormattedDomainPartIfSet($cookieStringParts);
222	20	$cookieStringParts = $this->appendFormattedPathPartIfSet($cookieStringParts);
223	20	$cookieStringParts = $this->appendFormattedExpiresPartIfSet($cookieStringParts);
224	20	$cookieStringParts = $this->appendFormattedMaxAgePartIfSet($cookieStringParts);
225	20	$cookieStringParts = $this->appendFormattedSecurePartIfSet($cookieStringParts);
226	20	$cookieStringParts = $this->appendFormattedHttpOnlyPartIfSet($cookieStringParts);
227	20	$cookieStringParts = $this->appendFormattedSameSitePartIfSet($cookieStringParts);
228
229	20	return implode('; ', $cookieStringParts);
230		}
231
232	10	public static function create(string $name, ?string $value = null): self
233		{
234	10	return new static($name, $value);
235		}
236
237	1	public static function createRememberedForever(string $name, ?string $value = null): self
238		{
239	1	return static::create($name, $value)->rememberForever();
240		}
241
242		/**
243		* @deprecated Do not use this method. Will be removed in v4.0.
244		*
245		* If you want to remove a cookie, create it normally and call ->expire()
246		* on the SetCookie object.
247		*/
248		public static function createExpired(string $name): self
249		{
250		return static::create($name)->expire();
251		}
252
253	32	public static function fromSetCookieString(string $string): self
254		{
255	32	$rawAttributes = StringUtil::splitOnAttributeDelimiter($string);
256
257	32	$rawAttribute = array_shift($rawAttributes);
258
259	32	if (! is_string($rawAttribute)) {
260	1	throw new InvalidArgumentException(sprintf(
261	1	'The provided cookie string "%s" must have at least one attribute',
262	1	$string
263		));
264		}
265
266	31	[$cookieName, $cookieValue] = StringUtil::splitCookiePair($rawAttribute);
		0 ignored issues – show Bug introduced 2020-11-01 10:55 UTC by Report Bug Copy Issue Report The variable `$cookieName` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history... Bug introduced 2020-11-01 10:55 UTC by Report Bug Copy Issue Report The variable `$cookieValue` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
267
268	31	$setCookie = new static($cookieName);
269
270	31	if ($cookieValue !== null) {
271	31	$setCookie = $setCookie->withValue($cookieValue);
272		}
273
274	31	while ($rawAttribute = array_shift($rawAttributes)) {
275	14	$rawAttributePair = explode('=', $rawAttribute, 2);
276
277	14	$attributeKey = $rawAttributePair[0];
278	14	$attributeValue = count($rawAttributePair) > 1 ? $rawAttributePair[1] : null;
279
280	14	$attributeKey = strtolower($attributeKey);
281
282	14	switch ($attributeKey) {
283	14	case 'expires':
284	13	$setCookie = $setCookie->withExpires($attributeValue);
285	13	break;
286	14	case 'max-age':
287	6	$setCookie = $setCookie->withMaxAge((int) $attributeValue);
288	6	break;
289	14	case 'domain':
290	9	$setCookie = $setCookie->withDomain($attributeValue);
291	9	break;
292	14	case 'path':
293	14	$setCookie = $setCookie->withPath($attributeValue);
294	14	break;
295	14	case 'secure':
296	12	$setCookie = $setCookie->withSecure(true);
297	12	break;
298	14	case 'httponly':
299	14	$setCookie = $setCookie->withHttpOnly(true);
300	14	break;
301	2	case 'samesite':
302	2	$setCookie = $setCookie->withSameSite(SameSite::fromString((string) $attributeValue));
303	2	break;
304		}
305		}
306
307	31	return $setCookie;
308		}
309
310		/**
311		* @param string[] $cookieStringParts
312		*
313		* @return string[]
314		*/
315	20	private function appendFormattedDomainPartIfSet(array $cookieStringParts): array
316		{
317	20	if ($this->domain) {
		0 ignored issues – show Bug Best Practice introduced 2018-06-22 14:18 UTC by Report Bug Copy Issue Report The expression `$this->domain` of type `string\|null` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
318	9	$cookieStringParts[] = sprintf('Domain=%s', $this->domain);
319		}
320
321	20	return $cookieStringParts;
322		}
323
324		/**
325		* @param string[] $cookieStringParts
326		*
327		* @return string[]
328		*/
329	20	private function appendFormattedPathPartIfSet(array $cookieStringParts): array
330		{
331	20	if ($this->path) {
		0 ignored issues – show Bug Best Practice introduced 2018-06-22 14:18 UTC by Report Bug Copy Issue Report The expression `$this->path` of type `string\|null` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
332	10	$cookieStringParts[] = sprintf('Path=%s', $this->path);
333		}
334
335	20	return $cookieStringParts;
336		}
337
338		/**
339		* @param string[] $cookieStringParts
340		*
341		* @return string[]
342		*/
343	20	private function appendFormattedExpiresPartIfSet(array $cookieStringParts): array
344		{
345	20	if ($this->expires) {
346	9	$cookieStringParts[] = sprintf('Expires=%s', gmdate('D, d M Y H:i:s T', $this->expires));
347		}
348
349	20	return $cookieStringParts;
350		}
351
352		/**
353		* @param string[] $cookieStringParts
354		*
355		* @return string[]
356		*/
357	20	private function appendFormattedMaxAgePartIfSet(array $cookieStringParts): array
358		{
359	20	if ($this->maxAge) {
360	6	$cookieStringParts[] = sprintf('Max-Age=%s', $this->maxAge);
361		}
362
363	20	return $cookieStringParts;
364		}
365
366		/**
367		* @param string[] $cookieStringParts
368		*
369		* @return string[]
370		*/
371	20	private function appendFormattedSecurePartIfSet(array $cookieStringParts): array
372		{
373	20	if ($this->secure) {
374	8	$cookieStringParts[] = 'Secure';
375		}
376
377	20	return $cookieStringParts;
378		}
379
380		/**
381		* @param string[] $cookieStringParts
382		*
383		* @return string[]
384		*/
385	20	private function appendFormattedHttpOnlyPartIfSet(array $cookieStringParts): array
386		{
387	20	if ($this->httpOnly) {
388	10	$cookieStringParts[] = 'HttpOnly';
389		}
390
391	20	return $cookieStringParts;
392		}
393
394		/**
395		* @param string[] $cookieStringParts
396		*
397		* @return string[]
398		*/
399	20	private function appendFormattedSameSitePartIfSet(array $cookieStringParts): array
400		{
401	20	if ($this->sameSite === null) {
402	18	return $cookieStringParts;
403		}
404
405	3	$cookieStringParts[] = $this->sameSite->asString();
406
407	3	return $cookieStringParts;
408		}
409		}
410

dflydev / dflydev-fig-cookies

Push — main ( f06d77...6ba089 )

SetCookie::createExpired() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like