SetCookie::setDiscard() - Code Metrics - Inspection of "Add guzzle via composer" - godbout/alfred-time - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 8d12ff...458df2 )

by Guillaume

created 2017-05-02 09:55 UTC

SetCookie::setDiscard() A

↳ Parent: SetCookie

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	2
nc	1
nop	1
dl	0
loc	4
rs	10
c	0
b	0
f	0

<?php
namespace GuzzleHttp\Cookie;

/**
 * Set-Cookie object
 */
class SetCookie
{
    /** @var array */
    private static $defaults = [
        'Name'     => null,
        'Value'    => null,
        'Domain'   => null,
        'Path'     => '/',
        'Max-Age'  => null,
        'Expires'  => null,
        'Secure'   => false,
        'Discard'  => false,
        'HttpOnly' => false
    ];

    /** @var array Cookie data */
    private $data;

    /**
     * Create a new SetCookie object from a string
     *
     * @param string $cookie Set-Cookie header string
     *
     * @return self
     */
    public static function fromString($cookie)
    {
        // Create the default return array
        $data = self::$defaults;
        // Explode the cookie string using a series of semicolons
        $pieces = array_filter(array_map('trim', explode(';', $cookie)));
        // The name of the cookie (first kvp) must include an equal sign.
        if (empty($pieces) || !strpos($pieces[0], '=')) {
            return new self($data);
        }

        // Add the cookie pieces into the parsed data array
        foreach ($pieces as $part) {

            $cookieParts = explode('=', $part, 2);
            $key = trim($cookieParts[0]);
            $value = isset($cookieParts[1])
                ? trim($cookieParts[1], " \n\r\t\0\x0B")
                : true;

            // Only check for non-cookies when cookies have been found
            if (empty($data['Name'])) {
                $data['Name'] = $key;
                $data['Value'] = $value;
            } else {
                foreach (array_keys(self::$defaults) as $search) {
                    if (!strcasecmp($search, $key)) {
                        $data[$search] = $value;
                        continue 2;
                    }
                }
                $data[$key] = $value;
            }
        }

        return new self($data);
    }

    /**
     * @param array $data Array of cookie data provided by a Cookie parser
     */
    public function __construct(array $data = [])
    {
        $this->data = array_replace(self::$defaults, $data);
        // Extract the Expires value and turn it into a UNIX timestamp if needed
        if (!$this->getExpires() && $this->getMaxAge()) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            // Calculate the Expires date
            $this->setExpires(time() + $this->getMaxAge());
        } elseif ($this->getExpires() && !is_numeric($this->getExpires())) {
            $this->setExpires($this->getExpires());
        }
    }

    public function __toString()
    {
        $str = $this->data['Name'] . '=' . $this->data['Value'] . '; ';
        foreach ($this->data as $k => $v) {
            if ($k !== 'Name' && $k !== 'Value' && $v !== null && $v !== false) {
                if ($k === 'Expires') {
                    $str .= 'Expires=' . gmdate('D, d M Y H:i:s \G\M\T', $v) . '; ';
                } else {
                    $str .= ($v === true ? $k : "{$k}={$v}") . '; ';
                }
            }
        }

        return rtrim($str, '; ');
    }

    public function toArray()
    {
        return $this->data;
    }

    /**
     * Get the cookie name
     *
     * @return string
     */
    public function getName()
    {
        return $this->data['Name'];
    }

    /**
     * Set the cookie name
     *
     * @param string $name Cookie name
     */
    public function setName($name)
    {
        $this->data['Name'] = $name;
    }

    /**
     * Get the cookie value
     *
     * @return string
     */
    public function getValue()
    {
        return $this->data['Value'];
    }

    /**
     * Set the cookie value
     *
     * @param string $value Cookie value
     */
    public function setValue($value)
    {
        $this->data['Value'] = $value;
    }

    /**
     * Get the domain
     *
     * @return string|null
     */
    public function getDomain()
    {
        return $this->data['Domain'];
    }

    /**
     * Set the domain of the cookie
     *
     * @param string $domain
     */
    public function setDomain($domain)
    {
        $this->data['Domain'] = $domain;
    }

    /**
     * Get the path
     *
     * @return string
     */
    public function getPath()
    {
        return $this->data['Path'];
    }

    /**
     * Set the path of the cookie
     *
     * @param string $path Path of the cookie
     */
    public function setPath($path)
    {
        $this->data['Path'] = $path;
    }

    /**
     * Maximum lifetime of the cookie in seconds
     *
     * @return int|null
     */
    public function getMaxAge()
    {
        return $this->data['Max-Age'];
    }

    /**
     * Set the max-age of the cookie
     *
     * @param int $maxAge Max age of the cookie in seconds
     */
    public function setMaxAge($maxAge)
    {
        $this->data['Max-Age'] = $maxAge;
    }

    /**
     * The UNIX timestamp when the cookie Expires
     *
     * @return mixed
     */
    public function getExpires()
    {
        return $this->data['Expires'];
    }

    /**
     * Set the unix timestamp for which the cookie will expire
     *
     * @param int $timestamp Unix timestamp
     */
    public function setExpires($timestamp)
    {
        $this->data['Expires'] = is_numeric($timestamp)
            ? (int) $timestamp
            : strtotime($timestamp);
    }

    /**
     * Get whether or not this is a secure cookie
     *
     * @return null|bool
     */
    public function getSecure()
    {
        return $this->data['Secure'];
    }

    /**
     * Set whether or not the cookie is secure
     *
     * @param bool $secure Set to true or false if secure
     */
    public function setSecure($secure)
    {
        $this->data['Secure'] = $secure;
    }

    /**
     * Get whether or not this is a session cookie
     *
     * @return null|bool
     */
    public function getDiscard()
    {
        return $this->data['Discard'];
    }

    /**
     * Set whether or not this is a session cookie
     *
     * @param bool $discard Set to true or false if this is a session cookie
     */
    public function setDiscard($discard)
    {
        $this->data['Discard'] = $discard;
    }

    /**
     * Get whether or not this is an HTTP only cookie
     *
     * @return bool
     */
    public function getHttpOnly()
    {
        return $this->data['HttpOnly'];
    }

    /**
     * Set whether or not this is an HTTP only cookie
     *
     * @param bool $httpOnly Set to true or false if this is HTTP only
     */
    public function setHttpOnly($httpOnly)
    {
        $this->data['HttpOnly'] = $httpOnly;
    }

    /**
     * Check if the cookie matches a path value.
     *
     * A request-path path-matches a given cookie-path if at least one of
     * the following conditions holds:
     *
     * - The cookie-path and the request-path are identical.
     * - The cookie-path is a prefix of the request-path, and the last
     *   character of the cookie-path is %x2F ("/").
     * - The cookie-path is a prefix of the request-path, and the first
     *   character of the request-path that is not included in the cookie-
     *   path is a %x2F ("/") character.
     *
     * @param string $requestPath Path to check against
     *
     * @return bool
     */
    public function matchesPath($requestPath)
    {
        $cookiePath = $this->getPath();

        // Match on exact matches or when path is the default empty "/"
        if ($cookiePath === '/' || $cookiePath == $requestPath) {
            return true;
        }

        // Ensure that the cookie-path is a prefix of the request path.
        if (0 !== strpos($requestPath, $cookiePath)) {
            return false;
        }

        // Match if the last character of the cookie-path is "/"
        if (substr($cookiePath, -1, 1) === '/') {
            return true;
        }

        // Match if the first character not included in cookie path is "/"
        return substr($requestPath, strlen($cookiePath), 1) === '/';
    }

    /**
     * Check if the cookie matches a domain value
     *
     * @param string $domain Domain to check against
     *
     * @return bool
     */
    public function matchesDomain($domain)
    {
        // Remove the leading '.' as per spec in RFC 6265.
        // http://tools.ietf.org/html/rfc6265#section-5.2.3
        $cookieDomain = ltrim($this->getDomain(), '.');

        // Domain not set or exact match.
        if (!$cookieDomain || !strcasecmp($domain, $cookieDomain)) {
            return true;
        }

        // Matching the subdomain according to RFC 6265.
        // http://tools.ietf.org/html/rfc6265#section-5.1.3
        if (filter_var($domain, FILTER_VALIDATE_IP)) {
            return false;
        }

        return (bool) preg_match('/\.' . preg_quote($cookieDomain) . '$/', $domain);
    }

    /**
     * Check if the cookie is expired
     *
     * @return bool
     */
    public function isExpired()
    {
        return $this->getExpires() && time() > $this->getExpires();
    }

    /**
     * Check if the cookie is valid according to RFC 6265
     *
     * @return bool|string Returns true if valid or an error message if invalid
     */
    public function validate()
    {
        // Names must not be empty, but can be 0
        $name = $this->getName();
        if (empty($name) && !is_numeric($name)) {
            return 'The cookie name must not be empty';
        }

        // Check if any of the invalid characters are present in the cookie name
        if (preg_match(
            '/[\x00-\x20\x22\x28-\x29\x2c\x2f\x3a-\x40\x5c\x7b\x7d\x7f]/',
            $name)
        ) {
            return 'Cookie name must not contain invalid characters: ASCII '
                . 'Control characters (0-31;127), space, tab and the '
                . 'following characters: ()<>@,;:\"/?={}';
        }

        // Value must not be empty, but can be 0
        $value = $this->getValue();
        if (empty($value) && !is_numeric($value)) {
            return 'The cookie value must not be empty';
        }

        // Domains must not be empty, but can be 0
        // A "0" is not a valid internet domain, but may be used as server name
        // in a private network.
        $domain = $this->getDomain();
        if (empty($domain) && !is_numeric($domain)) {
            return 'The cookie domain must not be empty';
        }

        return true;
    }
}


1			<?php
2			namespace GuzzleHttp\Cookie;
3
4			/**
5			* Set-Cookie object
6			*/
7			class SetCookie
8			{
9			/** @var array */
10			private static $defaults = [
11			'Name' => null,
12			'Value' => null,
13			'Domain' => null,
14			'Path' => '/',
15			'Max-Age' => null,
16			'Expires' => null,
17			'Secure' => false,
18			'Discard' => false,
19			'HttpOnly' => false
20			];
21
22			/** @var array Cookie data */
23			private $data;
24
25			/**
26			* Create a new SetCookie object from a string
27			*
28			* @param string $cookie Set-Cookie header string
29			*
30			* @return self
31			*/
32			public static function fromString($cookie)
33			{
34			// Create the default return array
35			$data = self::$defaults;
36			// Explode the cookie string using a series of semicolons
37			$pieces = array_filter(array_map('trim', explode(';', $cookie)));
38			// The name of the cookie (first kvp) must include an equal sign.
39			if (empty($pieces) \|\| !strpos($pieces[0], '=')) {
40			return new self($data);
41			}
42
43			// Add the cookie pieces into the parsed data array
44			foreach ($pieces as $part) {
45
46			$cookieParts = explode('=', $part, 2);
47			$key = trim($cookieParts[0]);
48			$value = isset($cookieParts[1])
49			? trim($cookieParts[1], " \n\r\t\0\x0B")
50			: true;
51
52			// Only check for non-cookies when cookies have been found
53			if (empty($data['Name'])) {
54			$data['Name'] = $key;
55			$data['Value'] = $value;
56			} else {
57			foreach (array_keys(self::$defaults) as $search) {
58			if (!strcasecmp($search, $key)) {
59			$data[$search] = $value;
60			continue 2;
61			}
62			}
63			$data[$key] = $value;
64			}
65			}
66
67			return new self($data);
68			}
69
70			/**
71			* @param array $data Array of cookie data provided by a Cookie parser
72			*/
73			public function __construct(array $data = [])
74			{
75			$this->data = array_replace(self::$defaults, $data);
76			// Extract the Expires value and turn it into a UNIX timestamp if needed
77			if (!$this->getExpires() && $this->getMaxAge()) {
			0 ignored issues – show Bug Best Practice introduced 2017-05-02 09:57 UTC by Report Bug Copy Issue Report The expression `$this->getMaxAge()` of type `integer\|null` is loosely compared to `true`; this is ambiguous if the integer can be zero. 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 `integer` values, zero is a special case, in particular the following results might be unexpected: 0 == false // true 0 == null // true 123 == false // false 123 == null // false // It is often better to use strict comparison 0 === false // false 0 === null // false Loading history...
78			// Calculate the Expires date
79			$this->setExpires(time() + $this->getMaxAge());
80			} elseif ($this->getExpires() && !is_numeric($this->getExpires())) {
81			$this->setExpires($this->getExpires());
82			}
83			}
84
85			public function __toString()
86			{
87			$str = $this->data['Name'] . '=' . $this->data['Value'] . '; ';
88			foreach ($this->data as $k => $v) {
89			if ($k !== 'Name' && $k !== 'Value' && $v !== null && $v !== false) {
90			if ($k === 'Expires') {
91			$str .= 'Expires=' . gmdate('D, d M Y H:i:s \G\M\T', $v) . '; ';
92			} else {
93			$str .= ($v === true ? $k : "{$k}={$v}") . '; ';
94			}
95			}
96			}
97
98			return rtrim($str, '; ');
99			}
100
101			public function toArray()
102			{
103			return $this->data;
104			}
105
106			/**
107			* Get the cookie name
108			*
109			* @return string
110			*/
111			public function getName()
112			{
113			return $this->data['Name'];
114			}
115
116			/**
117			* Set the cookie name
118			*
119			* @param string $name Cookie name
120			*/
121			public function setName($name)
122			{
123			$this->data['Name'] = $name;
124			}
125
126			/**
127			* Get the cookie value
128			*
129			* @return string
130			*/
131			public function getValue()
132			{
133			return $this->data['Value'];
134			}
135
136			/**
137			* Set the cookie value
138			*
139			* @param string $value Cookie value
140			*/
141			public function setValue($value)
142			{
143			$this->data['Value'] = $value;
144			}
145
146			/**
147			* Get the domain
148			*
149			* @return string\|null
150			*/
151			public function getDomain()
152			{
153			return $this->data['Domain'];
154			}
155
156			/**
157			* Set the domain of the cookie
158			*
159			* @param string $domain
160			*/
161			public function setDomain($domain)
162			{
163			$this->data['Domain'] = $domain;
164			}
165
166			/**
167			* Get the path
168			*
169			* @return string
170			*/
171			public function getPath()
172			{
173			return $this->data['Path'];
174			}
175
176			/**
177			* Set the path of the cookie
178			*
179			* @param string $path Path of the cookie
180			*/
181			public function setPath($path)
182			{
183			$this->data['Path'] = $path;
184			}
185
186			/**
187			* Maximum lifetime of the cookie in seconds
188			*
189			* @return int\|null
190			*/
191			public function getMaxAge()
192			{
193			return $this->data['Max-Age'];
194			}
195
196			/**
197			* Set the max-age of the cookie
198			*
199			* @param int $maxAge Max age of the cookie in seconds
200			*/
201			public function setMaxAge($maxAge)
202			{
203			$this->data['Max-Age'] = $maxAge;
204			}
205
206			/**
207			* The UNIX timestamp when the cookie Expires
208			*
209			* @return mixed
210			*/
211			public function getExpires()
212			{
213			return $this->data['Expires'];
214			}
215
216			/**
217			* Set the unix timestamp for which the cookie will expire
218			*
219			* @param int $timestamp Unix timestamp
220			*/
221			public function setExpires($timestamp)
222			{
223			$this->data['Expires'] = is_numeric($timestamp)
224			? (int) $timestamp
225			: strtotime($timestamp);
226			}
227
228			/**
229			* Get whether or not this is a secure cookie
230			*
231			* @return null\|bool
232			*/
233			public function getSecure()
234			{
235			return $this->data['Secure'];
236			}
237
238			/**
239			* Set whether or not the cookie is secure
240			*
241			* @param bool $secure Set to true or false if secure
242			*/
243			public function setSecure($secure)
244			{
245			$this->data['Secure'] = $secure;
246			}
247
248			/**
249			* Get whether or not this is a session cookie
250			*
251			* @return null\|bool
252			*/
253			public function getDiscard()
254			{
255			return $this->data['Discard'];
256			}
257
258			/**
259			* Set whether or not this is a session cookie
260			*
261			* @param bool $discard Set to true or false if this is a session cookie
262			*/
263			public function setDiscard($discard)
264			{
265			$this->data['Discard'] = $discard;
266			}
267
268			/**
269			* Get whether or not this is an HTTP only cookie
270			*
271			* @return bool
272			*/
273			public function getHttpOnly()
274			{
275			return $this->data['HttpOnly'];
276			}
277
278			/**
279			* Set whether or not this is an HTTP only cookie
280			*
281			* @param bool $httpOnly Set to true or false if this is HTTP only
282			*/
283			public function setHttpOnly($httpOnly)
284			{
285			$this->data['HttpOnly'] = $httpOnly;
286			}
287
288			/**
289			* Check if the cookie matches a path value.
290			*
291			* A request-path path-matches a given cookie-path if at least one of
292			* the following conditions holds:
293			*
294			* - The cookie-path and the request-path are identical.
295			* - The cookie-path is a prefix of the request-path, and the last
296			* character of the cookie-path is %x2F ("/").
297			* - The cookie-path is a prefix of the request-path, and the first
298			* character of the request-path that is not included in the cookie-
299			* path is a %x2F ("/") character.
300			*
301			* @param string $requestPath Path to check against
302			*
303			* @return bool
304			*/
305			public function matchesPath($requestPath)
306			{
307			$cookiePath = $this->getPath();
308
309			// Match on exact matches or when path is the default empty "/"
310			if ($cookiePath === '/' \|\| $cookiePath == $requestPath) {
311			return true;
312			}
313
314			// Ensure that the cookie-path is a prefix of the request path.
315			if (0 !== strpos($requestPath, $cookiePath)) {
316			return false;
317			}
318
319			// Match if the last character of the cookie-path is "/"
320			if (substr($cookiePath, -1, 1) === '/') {
321			return true;
322			}
323
324			// Match if the first character not included in cookie path is "/"
325			return substr($requestPath, strlen($cookiePath), 1) === '/';
326			}
327
328			/**
329			* Check if the cookie matches a domain value
330			*
331			* @param string $domain Domain to check against
332			*
333			* @return bool
334			*/
335			public function matchesDomain($domain)
336			{
337			// Remove the leading '.' as per spec in RFC 6265.
338			// http://tools.ietf.org/html/rfc6265#section-5.2.3
339			$cookieDomain = ltrim($this->getDomain(), '.');
340
341			// Domain not set or exact match.
342			if (!$cookieDomain \|\| !strcasecmp($domain, $cookieDomain)) {
343			return true;
344			}
345
346			// Matching the subdomain according to RFC 6265.
347			// http://tools.ietf.org/html/rfc6265#section-5.1.3
348			if (filter_var($domain, FILTER_VALIDATE_IP)) {
349			return false;
350			}
351
352			return (bool) preg_match('/\.' . preg_quote($cookieDomain) . '$/', $domain);
353			}
354
355			/**
356			* Check if the cookie is expired
357			*
358			* @return bool
359			*/
360			public function isExpired()
361			{
362			return $this->getExpires() && time() > $this->getExpires();
363			}
364
365			/**
366			* Check if the cookie is valid according to RFC 6265
367			*
368			* @return bool\|string Returns true if valid or an error message if invalid
369			*/
370			public function validate()
371			{
372			// Names must not be empty, but can be 0
373			$name = $this->getName();
374			if (empty($name) && !is_numeric($name)) {
375			return 'The cookie name must not be empty';
376			}
377
378			// Check if any of the invalid characters are present in the cookie name
379			if (preg_match(
380			'/[\x00-\x20\x22\x28-\x29\x2c\x2f\x3a-\x40\x5c\x7b\x7d\x7f]/',
381			$name)
382			) {
383			return 'Cookie name must not contain invalid characters: ASCII '
384			. 'Control characters (0-31;127), space, tab and the '
385			. 'following characters: ()<>@,;:\"/?={}';
386			}
387
388			// Value must not be empty, but can be 0
389			$value = $this->getValue();
390			if (empty($value) && !is_numeric($value)) {
391			return 'The cookie value must not be empty';
392			}
393
394			// Domains must not be empty, but can be 0
395			// A "0" is not a valid internet domain, but may be used as server name
396			// in a private network.
397			$domain = $this->getDomain();
398			if (empty($domain) && !is_numeric($domain)) {
399			return 'The cookie domain must not be empty';
400			}
401
402			return true;
403			}
404			}
405

godbout / alfred-time

Push — master ( 8d12ff...458df2 )

SetCookie::setDiscard() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like