Checks whether a method/function call has too many arguments.
These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more
1 | <?php |
||
2 | namespace Peridot\Leo\Interfaces; |
||
3 | |||
4 | use Peridot\Leo\Interfaces\Assert\CollectionAssertTrait; |
||
5 | use Peridot\Leo\Interfaces\Assert\ObjectAssertTrait; |
||
6 | use Peridot\Leo\Interfaces\Assert\TypeAssertTrait; |
||
7 | use Peridot\Leo\Assertion; |
||
8 | use Peridot\Leo\Leo; |
||
9 | use Peridot\Leo\Responder\ResponderInterface; |
||
10 | |||
11 | /** |
||
12 | * Assert is a non-chainable, object oriented interface |
||
13 | * on top of a Leo Assertion. |
||
14 | * |
||
15 | * @method instanceOf() instanceOf(object $actual, string $expected, string $message = "") Perform an instanceof assertion. |
||
16 | * @method include() include(array $haystack, string $expected, string $message = "") Perform an inclusion assertion. |
||
17 | * |
||
18 | * @package Peridot\Leo\Interfaces |
||
19 | */ |
||
20 | class Assert |
||
21 | { |
||
22 | use TypeAssertTrait; |
||
23 | use ObjectAssertTrait; |
||
24 | use CollectionAssertTrait; |
||
25 | |||
26 | /** |
||
27 | * An array of operators mapping to assertions. |
||
28 | * |
||
29 | * @var array |
||
30 | */ |
||
31 | public static $operators = [ |
||
32 | '==' => 'loosely->equal', |
||
33 | '===' => 'equal', |
||
34 | '>' => 'above', |
||
35 | '>=' => 'least', |
||
36 | '<' => 'below', |
||
37 | '<=' => 'most', |
||
38 | '!=' => 'not->loosely->equal', |
||
39 | '!==' => 'not->equal' |
||
40 | ]; |
||
41 | |||
42 | /** |
||
43 | * @var Assertion |
||
44 | */ |
||
45 | protected $assertion; |
||
46 | |||
47 | /** |
||
48 | * @param ResponderInterface $responder |
||
49 | */ |
||
50 | public function __construct(Assertion $assertion = null) |
||
51 | { |
||
52 | if (is_null($assertion)) { |
||
53 | $assertion = Leo::assertion(); |
||
54 | } |
||
55 | $this->assertion = $assertion; |
||
56 | } |
||
57 | |||
58 | /** |
||
59 | * Perform an a loose equality assertion. |
||
60 | * |
||
61 | * @param mixed $actual |
||
62 | * @param mixed $expected |
||
63 | * @param string $message |
||
64 | */ |
||
65 | public function equal($actual, $expected, $message = "") |
||
66 | { |
||
67 | $this->assertion->setActual($actual); |
||
68 | return $this->assertion->to->loosely->equal($expected, $message); |
||
0 ignored issues
–
show
|
|||
69 | } |
||
70 | |||
71 | /** |
||
72 | * Perform a negated loose equality assertion. |
||
73 | * |
||
74 | * @param mixed $actual |
||
75 | * @param mixed $expected |
||
76 | * @param string $message |
||
77 | */ |
||
78 | public function notEqual($actual, $expected, $message = "") |
||
79 | { |
||
80 | $this->assertion->setActual($actual); |
||
81 | return $this->assertion->to->not->equal($expected, $message); |
||
0 ignored issues
–
show
The call to
Assertion::equal() has too many arguments starting with $expected .
This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the
Loading history...
|
|||
82 | } |
||
83 | |||
84 | /** |
||
85 | * Performs a throw assertion. |
||
86 | * |
||
87 | * @param callable $fn |
||
88 | * @param $exceptionType |
||
89 | * @param string $exceptionMessage |
||
90 | * @param string $message |
||
91 | */ |
||
92 | public function throws(callable $fn, $exceptionType, $exceptionMessage = "", $message = "") |
||
93 | { |
||
94 | $this->assertion->setActual($fn); |
||
95 | return $this->assertion->to->throw($exceptionType, $exceptionMessage, $message); |
||
0 ignored issues
–
show
The call to
Assertion::throw() has too many arguments starting with $exceptionType .
This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the
Loading history...
|
|||
96 | } |
||
97 | |||
98 | /** |
||
99 | * Performs a negated throw assertion. |
||
100 | * |
||
101 | * @param callable $fn |
||
102 | * @param $exceptionType |
||
103 | * @param string $exceptionMessage |
||
104 | * @param string $message |
||
105 | */ |
||
106 | public function doesNotThrow(callable $fn, $exceptionType, $exceptionMessage = "", $message = "") |
||
107 | { |
||
108 | $this->assertion->setActual($fn); |
||
109 | return $this->assertion->not->to->throw($exceptionType, $exceptionMessage, $message); |
||
0 ignored issues
–
show
The call to
Assertion::throw() has too many arguments starting with $exceptionType .
This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the
Loading history...
|
|||
110 | } |
||
111 | |||
112 | /** |
||
113 | * Perform an ok assertion. |
||
114 | * |
||
115 | * @param mixed $object |
||
116 | * @param string $message |
||
117 | */ |
||
118 | public function ok($object, $message = "") |
||
119 | { |
||
120 | $this->assertion->setActual($object); |
||
121 | return $this->assertion->to->be->ok($message); |
||
0 ignored issues
–
show
The call to
Assertion::ok() has too many arguments starting with $message .
This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the
Loading history...
|
|||
122 | } |
||
123 | |||
124 | /** |
||
125 | * Perform a negated assertion. |
||
126 | * |
||
127 | * @param mixed $object |
||
128 | * @param string $message |
||
129 | */ |
||
130 | public function notOk($object, $message = "") |
||
131 | { |
||
132 | $this->assertion->setActual($object); |
||
133 | return $this->assertion->to->not->be->ok($message); |
||
0 ignored issues
–
show
The call to
Assertion::ok() has too many arguments starting with $message .
This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the
Loading history...
|
|||
134 | } |
||
135 | |||
136 | /** |
||
137 | * Perform a strict equality assertion. |
||
138 | * |
||
139 | * @param mixed $actual |
||
140 | * @param mixed $expected |
||
141 | * @param string $message |
||
142 | */ |
||
143 | public function strictEqual($actual, $expected, $message = "") |
||
144 | { |
||
145 | $this->assertion->setActual($actual); |
||
146 | return $this->assertion->to->equal($expected, $message); |
||
0 ignored issues
–
show
The call to
Assertion::equal() has too many arguments starting with $expected .
This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the
Loading history...
|
|||
147 | } |
||
148 | |||
149 | /** |
||
150 | * Perform a negated strict equality assertion. |
||
151 | * |
||
152 | * @param mixed $actual |
||
153 | * @param mixed $expected |
||
154 | * @param string $message |
||
155 | */ |
||
156 | public function notStrictEqual($actual, $expected, $message = "") |
||
157 | { |
||
158 | $this->assertion->setActual($actual); |
||
159 | return $this->assertion->to->not->equal($expected, $message); |
||
0 ignored issues
–
show
The call to
Assertion::equal() has too many arguments starting with $expected .
This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the
Loading history...
|
|||
160 | } |
||
161 | |||
162 | /** |
||
163 | * Perform a pattern assertion. |
||
164 | * |
||
165 | * @param string $value |
||
166 | * @param string $pattern |
||
167 | * @param string $message |
||
168 | */ |
||
169 | public function match($value, $pattern, $message = "") |
||
170 | { |
||
171 | $this->assertion->setActual($value); |
||
172 | return $this->assertion->to->match($pattern, $message); |
||
0 ignored issues
–
show
The call to
Assertion::match() has too many arguments starting with $pattern .
This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the
Loading history...
|
|||
173 | } |
||
174 | |||
175 | /** |
||
176 | * Perform a negated pattern assertion. |
||
177 | * |
||
178 | * @param string $value |
||
179 | * @param string $pattern |
||
180 | * @param string $message |
||
181 | */ |
||
182 | public function notMatch($value, $pattern, $message = "") |
||
183 | { |
||
184 | $this->assertion->setActual($value); |
||
185 | return $this->assertion->to->not->match($pattern, $message); |
||
0 ignored issues
–
show
The call to
Assertion::match() has too many arguments starting with $pattern .
This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the
Loading history...
|
|||
186 | } |
||
187 | |||
188 | /** |
||
189 | * Compare two values using the given operator. |
||
190 | * |
||
191 | * @param mixed $left |
||
192 | * @param string $operator |
||
193 | * @param mixed $right |
||
194 | * @param string $message |
||
195 | */ |
||
196 | public function operator($left, $operator, $right, $message = "") |
||
197 | { |
||
198 | if (!isset(static::$operators[$operator])) { |
||
199 | throw new \InvalidArgumentException("Invalid operator $operator"); |
||
200 | } |
||
201 | $this->assertion->setActual($left); |
||
202 | return $this->assertion->{static::$operators[$operator]}($right, $message); |
||
203 | } |
||
204 | |||
205 | /** |
||
206 | * Defined to allow use of reserved words for methods. |
||
207 | * |
||
208 | * @param $method |
||
209 | * @param $args |
||
210 | */ |
||
211 | public function __call($method, $args) |
||
212 | { |
||
213 | switch ($method) { |
||
214 | case 'instanceOf': |
||
215 | return call_user_func_array([$this, 'isInstanceOf'], $args); |
||
216 | case 'include': |
||
217 | return call_user_func_array([$this, 'isIncluded'], $args); |
||
218 | default: |
||
219 | throw new \BadMethodCallException("Call to undefined method $method"); |
||
220 | } |
||
221 | } |
||
222 | } |
||
223 |
This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue.
If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress.
In this case you can add the
@ignore
PhpDoc annotation to the duplicate definition and it will be ignored.