These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more
1 | <?php |
||
2 | /** |
||
3 | * |
||
4 | */ |
||
5 | |||
6 | namespace Mvc5\Session\Config; |
||
7 | |||
8 | use Mvc5\Arg; |
||
9 | use Mvc5\Config\ArrayAccess; |
||
10 | use Mvc5\Config\PropertyAccess; |
||
11 | use Mvc5\Cookie\Cookies; |
||
12 | |||
13 | trait Session |
||
14 | { |
||
15 | /** |
||
16 | * |
||
17 | */ |
||
18 | use ArrayAccess; |
||
19 | use PropertyAccess; |
||
20 | |||
21 | /** |
||
22 | * @var Cookies |
||
23 | */ |
||
24 | protected $cookies; |
||
25 | |||
26 | /** |
||
27 | * @param Cookies $cookies |
||
28 | */ |
||
29 | 53 | function __construct(Cookies $cookies = null) |
|
0 ignored issues
–
show
|
|||
30 | { |
||
31 | 53 | $this->cookies = $cookies; |
|
32 | 53 | } |
|
33 | |||
34 | /** |
||
35 | * |
||
36 | */ |
||
37 | 1 | function clear() |
|
0 ignored issues
–
show
clear uses the super-global variable $_SESSION which is generally not recommended.
Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad
class Router
{
public function generate($path)
{
return $_SERVER['HOST'].$path;
}
}
// Better
class Router
{
private $host;
public function __construct($host)
{
$this->host = $host;
}
public function generate($path)
{
return $this->host.$path;
}
}
class Controller
{
public function myAction(Request $request)
{
// Instead of
$page = isset($_GET['page']) ? intval($_GET['page']) : 1;
// Better (assuming you use the Symfony2 request)
$page = $request->query->get('page', 1);
}
}
Loading history...
|
|||
38 | { |
||
39 | 1 | $_SESSION = []; |
|
40 | 1 | } |
|
41 | |||
42 | /** |
||
43 | * |
||
44 | */ |
||
45 | 3 | function close() |
|
0 ignored issues
–
show
|
|||
46 | { |
||
47 | 3 | session_write_close(); |
|
48 | 3 | } |
|
49 | |||
50 | /** |
||
51 | * @return int |
||
52 | */ |
||
53 | 2 | function count() |
|
0 ignored issues
–
show
count uses the super-global variable $_SESSION which is generally not recommended.
Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad
class Router
{
public function generate($path)
{
return $_SERVER['HOST'].$path;
}
}
// Better
class Router
{
private $host;
public function __construct($host)
{
$this->host = $host;
}
public function generate($path)
{
return $this->host.$path;
}
}
class Controller
{
public function myAction(Request $request)
{
// Instead of
$page = isset($_GET['page']) ? intval($_GET['page']) : 1;
// Better (assuming you use the Symfony2 request)
$page = $request->query->get('page', 1);
}
}
Loading history...
|
|||
54 | { |
||
55 | 2 | return count($_SESSION); |
|
56 | } |
||
57 | |||
58 | /** |
||
59 | * @return mixed |
||
60 | */ |
||
61 | 3 | function current() |
|
0 ignored issues
–
show
current uses the super-global variable $_SESSION which is generally not recommended.
Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad
class Router
{
public function generate($path)
{
return $_SERVER['HOST'].$path;
}
}
// Better
class Router
{
private $host;
public function __construct($host)
{
$this->host = $host;
}
public function generate($path)
{
return $this->host.$path;
}
}
class Controller
{
public function myAction(Request $request)
{
// Instead of
$page = isset($_GET['page']) ? intval($_GET['page']) : 1;
// Better (assuming you use the Symfony2 request)
$page = $request->query->get('page', 1);
}
}
Loading history...
|
|||
62 | { |
||
63 | 3 | return current($_SESSION); |
|
64 | } |
||
65 | |||
66 | /** |
||
67 | * @param bool $remove_session_cookie |
||
68 | * @return bool |
||
69 | */ |
||
70 | 42 | function destroy($remove_session_cookie = true) |
|
0 ignored issues
–
show
|
|||
71 | { |
||
72 | 42 | $remove_session_cookie && |
|
73 | 4 | $this->removeSessionCookie($this->name(), session_get_cookie_params()); |
|
74 | |||
75 | 42 | return session_destroy(); |
|
76 | } |
||
77 | |||
78 | /** |
||
79 | * @param string $name |
||
80 | * @return mixed |
||
81 | */ |
||
82 | 11 | function &get($name) |
|
0 ignored issues
–
show
get uses the super-global variable $_SESSION which is generally not recommended.
Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad
class Router
{
public function generate($path)
{
return $_SERVER['HOST'].$path;
}
}
// Better
class Router
{
private $host;
public function __construct($host)
{
$this->host = $host;
}
public function generate($path)
{
return $this->host.$path;
}
}
class Controller
{
public function myAction(Request $request)
{
// Instead of
$page = isset($_GET['page']) ? intval($_GET['page']) : 1;
// Better (assuming you use the Symfony2 request)
$page = $request->query->get('page', 1);
}
}
Loading history...
|
|||
83 | { |
||
84 | 11 | return $_SESSION[$name]; |
|
85 | } |
||
86 | |||
87 | /** |
||
88 | * @param string $name |
||
89 | * @return bool |
||
90 | */ |
||
91 | 17 | function has($name) |
|
0 ignored issues
–
show
has uses the super-global variable $_SESSION which is generally not recommended.
Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad
class Router
{
public function generate($path)
{
return $_SERVER['HOST'].$path;
}
}
// Better
class Router
{
private $host;
public function __construct($host)
{
$this->host = $host;
}
public function generate($path)
{
return $this->host.$path;
}
}
class Controller
{
public function myAction(Request $request)
{
// Instead of
$page = isset($_GET['page']) ? intval($_GET['page']) : 1;
// Better (assuming you use the Symfony2 request)
$page = $request->query->get('page', 1);
}
}
Loading history...
|
|||
92 | { |
||
93 | 17 | return isset($_SESSION[$name]); |
|
94 | } |
||
95 | |||
96 | /** |
||
97 | * @param string $id |
||
98 | * @return string |
||
99 | */ |
||
100 | 12 | function id($id = null) |
|
0 ignored issues
–
show
|
|||
101 | { |
||
102 | 12 | return null !== $id ? session_id($id) : session_id(); |
|
103 | } |
||
104 | |||
105 | /** |
||
106 | * @return mixed |
||
107 | */ |
||
108 | 2 | function key() |
|
0 ignored issues
–
show
key uses the super-global variable $_SESSION which is generally not recommended.
Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad
class Router
{
public function generate($path)
{
return $_SERVER['HOST'].$path;
}
}
// Better
class Router
{
private $host;
public function __construct($host)
{
$this->host = $host;
}
public function generate($path)
{
return $this->host.$path;
}
}
class Controller
{
public function myAction(Request $request)
{
// Instead of
$page = isset($_GET['page']) ? intval($_GET['page']) : 1;
// Better (assuming you use the Symfony2 request)
$page = $request->query->get('page', 1);
}
}
Loading history...
|
|||
109 | { |
||
110 | 2 | return key($_SESSION); |
|
111 | } |
||
112 | |||
113 | /** |
||
114 | * @param string $name |
||
115 | * @return string |
||
116 | */ |
||
117 | 8 | function name($name = null) |
|
0 ignored issues
–
show
|
|||
118 | { |
||
119 | 8 | return null !== $name ? session_name($name) : session_name(); |
|
120 | } |
||
121 | |||
122 | /** |
||
123 | * |
||
124 | */ |
||
125 | 2 | function next() |
|
0 ignored issues
–
show
next uses the super-global variable $_SESSION which is generally not recommended.
Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad
class Router
{
public function generate($path)
{
return $_SERVER['HOST'].$path;
}
}
// Better
class Router
{
private $host;
public function __construct($host)
{
$this->host = $host;
}
public function generate($path)
{
return $this->host.$path;
}
}
class Controller
{
public function myAction(Request $request)
{
// Instead of
$page = isset($_GET['page']) ? intval($_GET['page']) : 1;
// Better (assuming you use the Symfony2 request)
$page = $request->query->get('page', 1);
}
}
Loading history...
|
|||
126 | { |
||
127 | 2 | next($_SESSION); |
|
128 | 2 | } |
|
129 | |||
130 | /** |
||
131 | * @param mixed $name |
||
132 | * @return mixed |
||
133 | */ |
||
134 | 5 | function &offsetGet($name) |
|
135 | { |
||
136 | 5 | return $this->get($name); |
|
137 | } |
||
138 | |||
139 | /** |
||
140 | * @param bool|false $delete_old_session |
||
141 | */ |
||
142 | 2 | function regenerate($delete_old_session = false) |
|
0 ignored issues
–
show
|
|||
143 | { |
||
144 | 2 | session_regenerate_id($delete_old_session); |
|
145 | 2 | } |
|
146 | |||
147 | /** |
||
148 | * @param string $name |
||
149 | * @return void |
||
150 | */ |
||
151 | 2 | function remove($name) |
|
0 ignored issues
–
show
remove uses the super-global variable $_SESSION which is generally not recommended.
Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad
class Router
{
public function generate($path)
{
return $_SERVER['HOST'].$path;
}
}
// Better
class Router
{
private $host;
public function __construct($host)
{
$this->host = $host;
}
public function generate($path)
{
return $this->host.$path;
}
}
class Controller
{
public function myAction(Request $request)
{
// Instead of
$page = isset($_GET['page']) ? intval($_GET['page']) : 1;
// Better (assuming you use the Symfony2 request)
$page = $request->query->get('page', 1);
}
}
Loading history...
|
|||
152 | { |
||
153 | 2 | unset($_SESSION[$name]); |
|
154 | 2 | } |
|
155 | |||
156 | /** |
||
157 | * @param $name |
||
158 | * @param array $params |
||
159 | */ |
||
160 | 4 | protected function removeSessionCookie($name, array $params = []) |
|
161 | { |
||
162 | 4 | $this->cookies ? |
|
163 | 2 | $this->cookies->remove($name, $params[Arg::PATH], $params[Arg::DOMAIN], $params[Arg::SECURE]) |
|
164 | 2 | : setcookie($name, false, 946706400, $params[Arg::PATH], $params[Arg::DOMAIN], $params[Arg::SECURE]); |
|
165 | 4 | } |
|
166 | |||
167 | /** |
||
168 | * |
||
169 | */ |
||
170 | 1 | function rewind() |
|
0 ignored issues
–
show
rewind uses the super-global variable $_SESSION which is generally not recommended.
Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad
class Router
{
public function generate($path)
{
return $_SERVER['HOST'].$path;
}
}
// Better
class Router
{
private $host;
public function __construct($host)
{
$this->host = $host;
}
public function generate($path)
{
return $this->host.$path;
}
}
class Controller
{
public function myAction(Request $request)
{
// Instead of
$page = isset($_GET['page']) ? intval($_GET['page']) : 1;
// Better (assuming you use the Symfony2 request)
$page = $request->query->get('page', 1);
}
}
Loading history...
|
|||
171 | { |
||
172 | 1 | reset($_SESSION); |
|
173 | 1 | } |
|
174 | |||
175 | /** |
||
176 | * @param string $name |
||
177 | * @param mixed $value |
||
178 | * @return mixed |
||
179 | */ |
||
180 | 31 | function set($name, $value) |
|
0 ignored issues
–
show
set uses the super-global variable $_SESSION which is generally not recommended.
Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad
class Router
{
public function generate($path)
{
return $_SERVER['HOST'].$path;
}
}
// Better
class Router
{
private $host;
public function __construct($host)
{
$this->host = $host;
}
public function generate($path)
{
return $this->host.$path;
}
}
class Controller
{
public function myAction(Request $request)
{
// Instead of
$page = isset($_GET['page']) ? intval($_GET['page']) : 1;
// Better (assuming you use the Symfony2 request)
$page = $request->query->get('page', 1);
}
}
Loading history...
|
|||
181 | { |
||
182 | 31 | return $_SESSION[$name] = $value; |
|
183 | } |
||
184 | |||
185 | /** |
||
186 | * @param array $options |
||
187 | * @return bool |
||
188 | */ |
||
189 | 44 | function start(array $options = []) |
|
0 ignored issues
–
show
|
|||
190 | { |
||
191 | 44 | return PHP_SESSION_ACTIVE === $this->status() ?: session_start($options); |
|
192 | } |
||
193 | |||
194 | /** |
||
195 | * @return int |
||
196 | */ |
||
197 | 44 | function status() |
|
0 ignored issues
–
show
|
|||
198 | { |
||
199 | 44 | return session_status(); |
|
200 | } |
||
201 | |||
202 | /** |
||
203 | * @return bool |
||
204 | */ |
||
205 | 1 | function valid() |
|
0 ignored issues
–
show
|
|||
206 | { |
||
207 | 1 | return null !== $this->key(); |
|
208 | } |
||
209 | |||
210 | /** |
||
211 | * @param string $name |
||
212 | * @param mixed $config |
||
213 | * @return self|mixed |
||
214 | */ |
||
215 | 1 | function with($name, $config) |
|
0 ignored issues
–
show
|
|||
216 | { |
||
217 | 1 | $this->set($name, $config); |
|
218 | 1 | return $this; |
|
219 | } |
||
220 | |||
221 | /** |
||
222 | * @param string $name |
||
223 | * @return self|mixed |
||
224 | */ |
||
225 | 1 | function without($name) |
|
0 ignored issues
–
show
|
|||
226 | { |
||
227 | 1 | $this->remove($name); |
|
228 | 1 | return $this; |
|
229 | } |
||
230 | |||
231 | /** |
||
232 | * @param mixed $name |
||
233 | * @return mixed |
||
234 | */ |
||
235 | 1 | function &__get($name) |
|
236 | { |
||
237 | 1 | return $this->get($name); |
|
238 | } |
||
239 | } |
||
240 |
Adding explicit visibility (
private
,protected
, orpublic
) is generally recommend to communicate to other developers how, and from where this method is intended to be used.