Session::abort() - Code Metrics - Inspection of "set session module name" - juliangut/sessionware - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — 2.x (8ca90a)

by Julián

created 2017-03-05 20:07 UTC

Session::abort() A

↳ Parent: Session

Complexity

Conditions	2
Paths	2

Size

Total Lines	12
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	12
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	6
nc	2
nop	0

<?php

/*
 * sessionware (https://github.com/juliangut/sessionware).
 * PSR7 compatible session management.
 *
 * @license BSD-3-Clause
 * @link https://github.com/juliangut/sessionware
 * @author Julián Gutiérrez <[email protected]>
 */

declare(strict_types=1);

namespace Jgut\Sessionware;

use Jgut\Sessionware\Manager\Manager;
use League\Event\EmitterAwareInterface;
use League\Event\EmitterTrait;
use League\Event\Event;

/**
 * Session helper.
 */
class Session implements EmitterAwareInterface
{
    use EmitterTrait;

    /**
     * Session manager.
     *
     * @var Manager
     */
    protected $sessionManager;

    /**
     * Session initial data.
     *
     * @var array
     */
    protected $originalData;

    /**
     * Session data.
     *
     * @var array
     */
    protected $data;

    /**
     * Session constructor.
     *
     * @param Manager $sessionManager
     * @param array   $initialData
     *
     * @throws \InvalidArgumentException
     */
    public function __construct(Manager $sessionManager, array $initialData = [])
    {
        $this->sessionManager = $sessionManager;
        $this->data = [];

        foreach ($initialData as $key => $value) {
            $this->set($key, $value);
        }

        $this->originalData = $this->data;

        register_shutdown_function([$this, 'close']);
    }

    /**
     * Get session manager.
     *
     * @return Manager
     */
    public function getManager()
    {
        return $this->sessionManager;
    }

    /**
     * Start session.
     *
     * @throws \RuntimeException
     */
    public function start()
    {
        if ($this->isActive()) {
            return;
        }

        $this->emit(Event::named('pre.session_start'), $this);

        $this->originalData = $this->data = array_merge($this->data, $this->sessionManager->sessionStart());

        if ($this->sessionManager->shouldRegenerateId()) {
            $this->regenerateId();
        }

        $this->emit(Event::named('post.session_start'), $this);

        $this->manageTimeout();
    }

    /**
     * Regenerate session identifier keeping parameters.
     *
     * @throws \RuntimeException
     */
    public function regenerateId()
    {
        if (!$this->isActive()) {
            throw new \RuntimeException('Cannot regenerate a not started session');
        }

        $this->emit(Event::named('pre.session_regenerate_id'), $this);

        $this->sessionManager->sessionRegenerateId();

        $this->emit(Event::named('pre.session_regenerate_id'), $this);
    }

    /**
     * Revert session to its original data.
     */
    public function reset()
    {
        if (!$this->isActive()) {
            return;
        }

        $this->emit(Event::named('pre.session_reset'), $this);

        $this->data = $this->originalData;

        $this->emit(Event::named('pre.session_reset'), $this);
    }

    /**
     * Close session keeping original session data.
     */
    public function abort()
    {
        if (!$this->isActive()) {
            return;
        }

        $this->emit(Event::named('pre.session_abort'), $this);

        $this->sessionManager->sessionEnd($this->originalData);

        $this->emit(Event::named('pre.session_abort'), $this);
    }

    /**
     * Close session.
     */
    public function close()
    {
        if (!$this->isActive()) {
            return;
        }

        $this->emit(Event::named('pre.session_close'), $this);

        $this->sessionManager->sessionEnd($this->data);

        $this->emit(Event::named('pre.session_close'), $this);
    }

    /**
     * Destroy session.
     *
     * @throws \RuntimeException
     */
    public function destroy()
    {
        if (!$this->isActive()) {
            throw new \RuntimeException('Cannot destroy a not started session');
        }

        $this->emit(Event::named('pre.session_destroy'), $this);

        $this->sessionManager->sessionDestroy();

        $this->emit(Event::named('pre.session_destroy'), $this);

        $this->originalData = $this->data = [];
    }

    /**
     * Has session been started.
     *
     * @return bool
     */
    public function isActive() : bool
    {
        return $this->sessionManager->isSessionStarted();
    }

    /**
     * Has session been destroyed.
     *
     * @return bool
     */
    public function isDestroyed() : bool
    {
        return $this->sessionManager->isSessionDestroyed();
    }

    /**
     * Get session identifier.
     *
     * @return string
     */
    public function getId() : string
    {
        return $this->sessionManager->getSessionId();
    }

    /**
     * Set session identifier.
     *
     * @param string $sessionId
     *
     * @throws \RuntimeException
     */
    public function setId(string $sessionId)
    {
        if ($this->isActive() || $this->isDestroyed()) {
            throw new \RuntimeException('Cannot set session id on started or destroyed sessions');
        }

        $this->sessionManager->setSessionId($sessionId);
    }

    /**
     * Session parameter existence.
     *
     * @param string $key
     *
     * @return bool
     */
    public function has(string $key) : bool
    {
        return array_key_exists($key, $this->data);
    }

    /**
     * Retrieve session parameter.
     *
     * @param string     $key
     * @param mixed|null $default
     *
     * @return mixed
     */
    public function get(string $key, $default = null)
    {
        return array_key_exists($key, $this->data) ? $this->data[$key] : $default;
    }

    /**
     * Set session parameter.
     *
     * @param string $key
     * @param mixed  $value
     *
     * @throws \InvalidArgumentException
     *
     * @return self
     */
    public function set(string $key, $value) : self
    {
        $this->verifyScalarValue($value);

        $this->data[$key] = $value;

        return $this;
    }

    /**
     * Verify only scalar values allowed.
     *
     * @param string|int|float|bool|array $value
     *
     * @throws \InvalidArgumentException
     */
    final protected function verifyScalarValue($value)
    {
        if (is_array($value)) {
            foreach ($value as $val) {
                $this->verifyScalarValue($val);
            }
        }

        if (!is_scalar($value)) {
            throw new \InvalidArgumentException(sprintf('Session values must be scalars, %s given', gettype($value)));
        }
    }

    /**
     * Remove session parameter.
     *
     * @param string $key
     *
     * @return self
     */
    public function remove(string $key) : self
    {
        if (array_key_exists($key, $this->data)) {
            unset($this->data[$key]);
        }

        return $this;
    }

    /**
     * Remove all session parameters.
     *
     * @return self
     */
    public function clear() : self
    {
        $timeoutKey = $this->getConfiguration()->getTimeoutKey();
        $sessionTimeout = array_key_exists($timeoutKey, $this->data)
            ? $this->data[$timeoutKey]
            : time() + $this->getConfiguration()->getLifetime();

        $this->data = [$timeoutKey => $sessionTimeout];

        return $this;
    }

    /**
     * Manage session timeout.
     *
     * @throws \RuntimeException
     */
    protected function manageTimeout()
    {
        $configuration = $this->getConfiguration();
        $timeoutKey = $configuration->getTimeoutKey();

        if (array_key_exists($timeoutKey, $this->data) && $this->data[$timeoutKey] < time()) {
            $this->emit(Event::named('pre.session_timeout'), $this);

            $this->sessionManager->sessionRegenerateId();

            $this->emit(Event::named('post.session_timeout'), $this);
        }

        $this->data[$timeoutKey] = time() + $configuration->getLifetime();
    }

    /**
     * Get cookie header content.
     *
     * @return string
     */
    public function getCookieString() : string
    {
        $configuration = $this->getConfiguration();

        $timeoutKey = $configuration->getTimeoutKey();
        $expireTime = array_key_exists($timeoutKey, $this->data)
            ? $this->data[$timeoutKey]
            : time() + $configuration->getLifetime();

        return sprintf(
            '%s=%s; %s',
            urlencode($configuration->getName()),
            urlencode($this->getId()),
            $this->getCookieParameters($expireTime)
        );
    }

    /**
     * Get session cookie parameters.
     *
     * @param int $expireTime
     *
     * @return string
     */
    protected function getCookieParameters(int $expireTime) : string
    {
        $configuration = $this->getConfiguration();

        $cookieParams = [
            sprintf(
                'expires=%s; max-age=%s',
                gmdate('D, d M Y H:i:s T', $expireTime),
                $configuration->getLifetime()
            ),
        ];

        if (!empty($configuration->getCookiePath())) {
            $cookieParams[] = 'path=' . $configuration->getCookiePath();
        }

        if (!empty($configuration->getCookieDomain())) {
            $cookieParams[] = 'domain=' . $configuration->getCookieDomain();
        }

        if ($configuration->isCookieSecure()) {
            $cookieParams[] = 'secure';
        }

        if ($configuration->isCookieHttpOnly()) {
            $cookieParams[] = 'httponly';
        }

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

    /**
     * Get session configuration.
     *
     * @return Configuration
     */
    protected function getConfiguration() : Configuration
    {
        return $this->sessionManager->getConfiguration();
    }
}


1			<?php
2
3			/*
4			* sessionware (https://github.com/juliangut/sessionware).
5			* PSR7 compatible session management.
6			*
7			* @license BSD-3-Clause
8			* @link https://github.com/juliangut/sessionware
9			* @author Julián Gutiérrez <[email protected]>
10			*/
11
12			declare(strict_types=1);
13
14			namespace Jgut\Sessionware;
15
16			use Jgut\Sessionware\Manager\Manager;
17			use League\Event\EmitterAwareInterface;
18			use League\Event\EmitterTrait;
19			use League\Event\Event;
20
21			/**
22			* Session helper.
23			*/
24			class Session implements EmitterAwareInterface
25			{
26			use EmitterTrait;
27
28			/**
29			* Session manager.
30			*
31			* @var Manager
32			*/
33			protected $sessionManager;
34
35			/**
36			* Session initial data.
37			*
38			* @var array
39			*/
40			protected $originalData;
41
42			/**
43			* Session data.
44			*
45			* @var array
46			*/
47			protected $data;
48
49			/**
50			* Session constructor.
51			*
52			* @param Manager $sessionManager
53			* @param array $initialData
54			*
55			* @throws \InvalidArgumentException
56			*/
57			public function __construct(Manager $sessionManager, array $initialData = [])
58			{
59			$this->sessionManager = $sessionManager;
60			$this->data = [];
61
62			foreach ($initialData as $key => $value) {
63			$this->set($key, $value);
64			}
65
66			$this->originalData = $this->data;
67
68			register_shutdown_function([$this, 'close']);
69			}
70
71			/**
72			* Get session manager.
73			*
74			* @return Manager
75			*/
76			public function getManager()
77			{
78			return $this->sessionManager;
79			}
80
81			/**
82			* Start session.
83			*
84			* @throws \RuntimeException
85			*/
86			public function start()
87			{
88			if ($this->isActive()) {
89			return;
90			}
91
92			$this->emit(Event::named('pre.session_start'), $this);
93
94			$this->originalData = $this->data = array_merge($this->data, $this->sessionManager->sessionStart());
95
96			if ($this->sessionManager->shouldRegenerateId()) {
97			$this->regenerateId();
98			}
99
100			$this->emit(Event::named('post.session_start'), $this);
101
102			$this->manageTimeout();
103			}
104
105			/**
106			* Regenerate session identifier keeping parameters.
107			*
108			* @throws \RuntimeException
109			*/
110			public function regenerateId()
111			{
112			if (!$this->isActive()) {
113			throw new \RuntimeException('Cannot regenerate a not started session');
114			}
115
116			$this->emit(Event::named('pre.session_regenerate_id'), $this);
117
118			$this->sessionManager->sessionRegenerateId();
119
120			$this->emit(Event::named('pre.session_regenerate_id'), $this);
121			}
122
123			/**
124			* Revert session to its original data.
125			*/
126			public function reset()
127			{
128			if (!$this->isActive()) {
129			return;
130			}
131
132			$this->emit(Event::named('pre.session_reset'), $this);
133
134			$this->data = $this->originalData;
135
136			$this->emit(Event::named('pre.session_reset'), $this);
137			}
138
139			/**
140			* Close session keeping original session data.
141			*/
142			public function abort()
143			{
144			if (!$this->isActive()) {
145			return;
146			}
147
148			$this->emit(Event::named('pre.session_abort'), $this);
149
150			$this->sessionManager->sessionEnd($this->originalData);
151
152			$this->emit(Event::named('pre.session_abort'), $this);
153			}
154
155			/**
156			* Close session.
157			*/
158			public function close()
159			{
160			if (!$this->isActive()) {
161			return;
162			}
163
164			$this->emit(Event::named('pre.session_close'), $this);
165
166			$this->sessionManager->sessionEnd($this->data);
167
168			$this->emit(Event::named('pre.session_close'), $this);
169			}
170
171			/**
172			* Destroy session.
173			*
174			* @throws \RuntimeException
175			*/
176			public function destroy()
177			{
178			if (!$this->isActive()) {
179			throw new \RuntimeException('Cannot destroy a not started session');
180			}
181
182			$this->emit(Event::named('pre.session_destroy'), $this);
183
184			$this->sessionManager->sessionDestroy();
185
186			$this->emit(Event::named('pre.session_destroy'), $this);
187
188			$this->originalData = $this->data = [];
189			}
190
191			/**
192			* Has session been started.
193			*
194			* @return bool
195			*/
196			public function isActive() : bool
197			{
198			return $this->sessionManager->isSessionStarted();
199			}
200
201			/**
202			* Has session been destroyed.
203			*
204			* @return bool
205			*/
206			public function isDestroyed() : bool
207			{
208			return $this->sessionManager->isSessionDestroyed();
209			}
210
211			/**
212			* Get session identifier.
213			*
214			* @return string
215			*/
216			public function getId() : string
217			{
218			return $this->sessionManager->getSessionId();
219			}
220
221			/**
222			* Set session identifier.
223			*
224			* @param string $sessionId
225			*
226			* @throws \RuntimeException
227			*/
228			public function setId(string $sessionId)
229			{
230			if ($this->isActive() \|\| $this->isDestroyed()) {
231			throw new \RuntimeException('Cannot set session id on started or destroyed sessions');
232			}
233
234			$this->sessionManager->setSessionId($sessionId);
235			}
236
237			/**
238			* Session parameter existence.
239			*
240			* @param string $key
241			*
242			* @return bool
243			*/
244			public function has(string $key) : bool
245			{
246			return array_key_exists($key, $this->data);
247			}
248
249			/**
250			* Retrieve session parameter.
251			*
252			* @param string $key
253			* @param mixed\|null $default
254			*
255			* @return mixed
256			*/
257			public function get(string $key, $default = null)
258			{
259			return array_key_exists($key, $this->data) ? $this->data[$key] : $default;
260			}
261
262			/**
263			* Set session parameter.
264			*
265			* @param string $key
266			* @param mixed $value
267			*
268			* @throws \InvalidArgumentException
269			*
270			* @return self
271			*/
272			public function set(string $key, $value) : self
273			{
274			$this->verifyScalarValue($value);
275
276			$this->data[$key] = $value;
277
278			return $this;
279			}
280
281			/**
282			* Verify only scalar values allowed.
283			*
284			* @param string\|int\|float\|bool\|array $value
285			*
286			* @throws \InvalidArgumentException
287			*/
288			final protected function verifyScalarValue($value)
289			{
290			if (is_array($value)) {
291			foreach ($value as $val) {
292			$this->verifyScalarValue($val);
293			}
294			}
295
296			if (!is_scalar($value)) {
297			throw new \InvalidArgumentException(sprintf('Session values must be scalars, %s given', gettype($value)));
298			}
299			}
300
301			/**
302			* Remove session parameter.
303			*
304			* @param string $key
305			*
306			* @return self
307			*/
308			public function remove(string $key) : self
309			{
310			if (array_key_exists($key, $this->data)) {
311			unset($this->data[$key]);
312			}
313
314			return $this;
315			}
316
317			/**
318			* Remove all session parameters.
319			*
320			* @return self
321			*/
322			public function clear() : self
323			{
324			$timeoutKey = $this->getConfiguration()->getTimeoutKey();
325			$sessionTimeout = array_key_exists($timeoutKey, $this->data)
326			? $this->data[$timeoutKey]
327			: time() + $this->getConfiguration()->getLifetime();
328
329			$this->data = [$timeoutKey => $sessionTimeout];
330
331			return $this;
332			}
333
334			/**
335			* Manage session timeout.
336			*
337			* @throws \RuntimeException
338			*/
339			protected function manageTimeout()
340			{
341			$configuration = $this->getConfiguration();
342			$timeoutKey = $configuration->getTimeoutKey();
343
344			if (array_key_exists($timeoutKey, $this->data) && $this->data[$timeoutKey] < time()) {
345			$this->emit(Event::named('pre.session_timeout'), $this);
346
347			$this->sessionManager->sessionRegenerateId();
348
349			$this->emit(Event::named('post.session_timeout'), $this);
350			}
351
352			$this->data[$timeoutKey] = time() + $configuration->getLifetime();
353			}
354
355			/**
356			* Get cookie header content.
357			*
358			* @return string
359			*/
360			public function getCookieString() : string
361			{
362			$configuration = $this->getConfiguration();
363
364			$timeoutKey = $configuration->getTimeoutKey();
365			$expireTime = array_key_exists($timeoutKey, $this->data)
366			? $this->data[$timeoutKey]
367			: time() + $configuration->getLifetime();
368
369			return sprintf(
370			'%s=%s; %s',
371			urlencode($configuration->getName()),
372			urlencode($this->getId()),
373			$this->getCookieParameters($expireTime)
374			);
375			}
376
377			/**
378			* Get session cookie parameters.
379			*
380			* @param int $expireTime
381			*
382			* @return string
383			*/
384			protected function getCookieParameters(int $expireTime) : string
385			{
386			$configuration = $this->getConfiguration();
387
388			$cookieParams = [
389			sprintf(
390			'expires=%s; max-age=%s',
391			gmdate('D, d M Y H:i:s T', $expireTime),
392			$configuration->getLifetime()
393			),
394			];
395
396			if (!empty($configuration->getCookiePath())) {
397			$cookieParams[] = 'path=' . $configuration->getCookiePath();
398			}
399
400			if (!empty($configuration->getCookieDomain())) {
401			$cookieParams[] = 'domain=' . $configuration->getCookieDomain();
402			}
403
404			if ($configuration->isCookieSecure()) {
405			$cookieParams[] = 'secure';
406			}
407
408			if ($configuration->isCookieHttpOnly()) {
409			$cookieParams[] = 'httponly';
410			}
411
412			return implode('; ', $cookieParams);
413			}
414
415			/**
416			* Get session configuration.
417			*
418			* @return Configuration
419			*/
420			protected function getConfiguration() : Configuration
421			{
422			return $this->sessionManager->getConfiguration();
423			}
424			}
425

juliangut / sessionware

Branch — 2.x (8ca90a)

Session::abort() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like