ResponseCacheControl::withStaleIfError() - Code Metrics - micheh/psr7-cache - Measure and Improve Code Quality continuously with Scrutinizer

ResponseCacheControl::withStaleIfError() A
last analyzed 2016-04-15 16:35 UTC

↳ Parent: ResponseCacheControl

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	1

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

<?php
/**
 * PSR-7 Cache Helpers
 *
 * @copyright Copyright (c) 2016, Michel Hunziker <[email protected]>
 * @license http://www.opensource.org/licenses/BSD-3-Clause The BSD-3-Clause License
 */

namespace Micheh\Cache\Header;

/**
 * Cache-Control header for a response.
 */
class ResponseCacheControl extends CacheControl
{
    /**
     * {@inheritdoc}
     */
    protected static $directiveMethods = [
        'public' => 'withPublic',
        'private' => 'withPrivate',
        's-maxage' => 'withSharedMaxAge',
        'stale-while-revalidate' => 'withStaleWhileRevalidate',
        'stale-if-error' => 'withStaleIfError',
        'must-revalidate' => 'withMustRevalidate',
        'proxy-revalidate' => 'withProxyRevalidate',
    ];

    /**
     * Create a new Response Cache-Control object from a header string.
     *
     * @param string $string
     * @return static
     */
    public static function fromString($string)
    {
        return static::createFromString($string);
    }

    /**
     * Set whether a response should be cached by shared caches. The method will automatically
     * remove the private flag if it is set.
     *
     * @param bool $flag
     * @return static
     */
    public function withPublic($flag = true)
    {
        return $this->withPublicPrivate(true, $flag);
    }

    /**
     * @return bool
     */
    public function isPublic()
    {
        return $this->hasDirective('public');
    }

    /**
     * Set whether a response should be private (only cacheable by the client who made the request.
     * The method will automatically remove the public flag if it is set.
     *
     * @param bool $flag
     * @return static
     */
    public function withPrivate($flag = true)
    {
        return $this->withPublicPrivate(false, $flag);
    }

    /**
     * @return bool
     */
    public function isPrivate()
    {
        return $this->hasDirective('private');
    }

    /**
     * Set how many seconds shared caches should cache the response. Use this directive only if it
     * is different than the max age value.
     *
     * @param int $seconds
     * @return static
     */
    public function withSharedMaxAge($seconds)
    {
        return $this->withDirective('s-maxage', (int) $seconds);
    }

    /**
     * @return int|null
     */
    public function getSharedMaxAge()
    {
        return $this->getDirective('s-maxage');
    }

    /**
     * Returns the number of seconds the response should be cached. The method returns the shared
     * max age if available and the normal max age otherwise. If both directives are not available,
     * the method returns `null`.
     *
     * @return int|null Lifetime in seconds if available, null otherwise
     */
    public function getLifetime()
    {
        $lifetime = $this->getSharedMaxAge();
        if ($lifetime === null) {
            $lifetime = $this->getMaxAge();
        }

        return $lifetime;
    }

    /**
     * Set how many seconds a stale representation can be used while revalidating in the background.
     *
     * @param int $seconds
     * @return static
     */
    public function withStaleWhileRevalidate($seconds)
    {
        return $this->withDirective('stale-while-revalidate', (int) $seconds);
    }

    /**
     * @return int|null
     */
    public function getStaleWhileRevalidate()
    {
        return $this->getDirective('stale-while-revalidate');
    }

    /**
     * Set how many seconds a stale representation can be used in the case of a server error.
     *
     * @param int $seconds
     * @return static
     */
    public function withStaleIfError($seconds)
    {
        return $this->withDirective('stale-if-error', (int) $seconds);
    }

    /**
     * @return int|null
     */
    public function getStaleIfError()
    {
        return $this->getDirective('stale-if-error');
    }

    /**
     * Set whether a stale representation should be validated.
     *
     * @param bool $flag
     * @return static
     */
    public function withMustRevalidate($flag = true)
    {
        return $this->withDirective('must-revalidate', (bool) $flag);
    }

    /**
     * @return bool
     */
    public function hasMustRevalidate()
    {
        return $this->hasDirective('must-revalidate');
    }

    /**
     * Set whether a public cache should validate a stale representation.
     *
     * @param bool $flag
     * @return static
     */
    public function withProxyRevalidate($flag = true)
    {
        return $this->withDirective('proxy-revalidate', (bool) $flag);
    }

    /**
     * @return bool
     */
    public function hasProxyRevalidate()
    {
        return $this->hasDirective('proxy-revalidate');
    }

    /**
     * Convenience method to set flags which should prevent the client from caching.
     * Adds `no-cache, no-store, must-revalidate`.
     *
     * @return static
     */
    public function withCachePrevention()
    {
        return $this->withNoCache()->withNoStore()->withMustRevalidate();
    }

    /**
     * Sets the flag for the public and private directives.
     *
     * @param bool $isPublic
     * @param bool $flag
     * @return static
     */
    private function withPublicPrivate($isPublic, $flag)
    {
        $type = $isPublic ? 'public' : 'private';
        $otherType = $isPublic ? 'private' : 'public';

        $clone = $this->withDirective($type, (bool) $flag);
        if ($flag && $clone->hasDirective($otherType)) {
            $clone = $clone->withDirective($otherType, false);
        }

        return $clone;
    }
}


1		<?php
2		/**
3		* PSR-7 Cache Helpers
4		*
5		* @copyright Copyright (c) 2016, Michel Hunziker <[email protected]>
6		* @license http://www.opensource.org/licenses/BSD-3-Clause The BSD-3-Clause License
7		*/
8
9		namespace Micheh\Cache\Header;
10
11		/**
12		* Cache-Control header for a response.
13		*/
14		class ResponseCacheControl extends CacheControl
15		{
16		/**
17		* {@inheritdoc}
18		*/
19		protected static $directiveMethods = [
20		'public' => 'withPublic',
21		'private' => 'withPrivate',
22		's-maxage' => 'withSharedMaxAge',
23		'stale-while-revalidate' => 'withStaleWhileRevalidate',
24		'stale-if-error' => 'withStaleIfError',
25		'must-revalidate' => 'withMustRevalidate',
26		'proxy-revalidate' => 'withProxyRevalidate',
27		];
28
29		/**
30		* Create a new Response Cache-Control object from a header string.
31		*
32		* @param string $string
33		* @return static
34		*/
35	1	public static function fromString($string)
36		{
37	1	return static::createFromString($string);
38		}
39
40		/**
41		* Set whether a response should be cached by shared caches. The method will automatically
42		* remove the private flag if it is set.
43		*
44		* @param bool $flag
45		* @return static
46		*/
47	4	public function withPublic($flag = true)
48		{
49	4	return $this->withPublicPrivate(true, $flag);
50		}
51
52		/**
53		* @return bool
54		*/
55	1	public function isPublic()
56		{
57	1	return $this->hasDirective('public');
58		}
59
60		/**
61		* Set whether a response should be private (only cacheable by the client who made the request.
62		* The method will automatically remove the public flag if it is set.
63		*
64		* @param bool $flag
65		* @return static
66		*/
67	4	public function withPrivate($flag = true)
68		{
69	4	return $this->withPublicPrivate(false, $flag);
70		}
71
72		/**
73		* @return bool
74		*/
75	1	public function isPrivate()
76		{
77	1	return $this->hasDirective('private');
78		}
79
80		/**
81		* Set how many seconds shared caches should cache the response. Use this directive only if it
82		* is different than the max age value.
83		*
84		* @param int $seconds
85		* @return static
86		*/
87	1	public function withSharedMaxAge($seconds)
88		{
89	1	return $this->withDirective('s-maxage', (int) $seconds);
90		}
91
92		/**
93		* @return int\|null
94		*/
95	1	public function getSharedMaxAge()
96		{
97	1	return $this->getDirective('s-maxage');
98		}
99
100		/**
101		* Returns the number of seconds the response should be cached. The method returns the shared
102		* max age if available and the normal max age otherwise. If both directives are not available,
103		* the method returns `null`.
104		*
105		* @return int\|null Lifetime in seconds if available, null otherwise
106		*/
107	4	public function getLifetime()
108		{
109	4	$lifetime = $this->getSharedMaxAge();
110	4	if ($lifetime === null) {
111	2	$lifetime = $this->getMaxAge();
112	2	}
113
114	4	return $lifetime;
115		}
116
117		/**
118		* Set how many seconds a stale representation can be used while revalidating in the background.
119		*
120		* @param int $seconds
121		* @return static
122		*/
123	1	public function withStaleWhileRevalidate($seconds)
124		{
125	1	return $this->withDirective('stale-while-revalidate', (int) $seconds);
126		}
127
128		/**
129		* @return int\|null
130		*/
131	1	public function getStaleWhileRevalidate()
132		{
133	1	return $this->getDirective('stale-while-revalidate');
134		}
135
136		/**
137		* Set how many seconds a stale representation can be used in the case of a server error.
138		*
139		* @param int $seconds
140		* @return static
141		*/
142	1	public function withStaleIfError($seconds)
143		{
144	1	return $this->withDirective('stale-if-error', (int) $seconds);
145		}
146
147		/**
148		* @return int\|null
149		*/
150	1	public function getStaleIfError()
151		{
152	1	return $this->getDirective('stale-if-error');
153		}
154
155		/**
156		* Set whether a stale representation should be validated.
157		*
158		* @param bool $flag
159		* @return static
160		*/
161	1	public function withMustRevalidate($flag = true)
162		{
163	1	return $this->withDirective('must-revalidate', (bool) $flag);
164		}
165
166		/**
167		* @return bool
168		*/
169	1	public function hasMustRevalidate()
170		{
171	1	return $this->hasDirective('must-revalidate');
172		}
173
174		/**
175		* Set whether a public cache should validate a stale representation.
176		*
177		* @param bool $flag
178		* @return static
179		*/
180	1	public function withProxyRevalidate($flag = true)
181		{
182	1	return $this->withDirective('proxy-revalidate', (bool) $flag);
183		}
184
185		/**
186		* @return bool
187		*/
188	1	public function hasProxyRevalidate()
189		{
190	1	return $this->hasDirective('proxy-revalidate');
191		}
192
193		/**
194		* Convenience method to set flags which should prevent the client from caching.
195		* Adds `no-cache, no-store, must-revalidate`.
196		*
197		* @return static
198		*/
199	1	public function withCachePrevention()
200		{
201	1	return $this->withNoCache()->withNoStore()->withMustRevalidate();
202		}
203
204		/**
205		* Sets the flag for the public and private directives.
206		*
207		* @param bool $isPublic
208		* @param bool $flag
209		* @return static
210		*/
211	5	private function withPublicPrivate($isPublic, $flag)
212		{
213	5	$type = $isPublic ? 'public' : 'private';
214	5	$otherType = $isPublic ? 'private' : 'public';
215
216	5	$clone = $this->withDirective($type, (bool) $flag);
217	5	if ($flag && $clone->hasDirective($otherType)) {
218	2	$clone = $clone->withDirective($otherType, false);
219	2	}
220
221	5	return $clone;
222		}
223		}
224

micheh / psr7-cache

ResponseCacheControl::withStaleIfError() A last analyzed 2016-04-15 16:35 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

ResponseCacheControl::withStaleIfError() A
last analyzed 2016-04-15 16:35 UTC