jnvsor /
kint
| Conditions | 49 |
| Paths | 24 |
| Total Lines | 239 |
| Code Lines | 146 |
| Lines | 0 |
| Ratio | 0 % |
| Changes | 0 | ||
Small methods make your code easier to understand, in particular if combined with a good name. Besides, if your method is small, finding a good name is usually much easier.
For example, if you find yourself adding comments to a method's body, this is usually a good sign to extract the commented part to a new method, and use the comment as a starting point when coming up with a good name for this new method.
Commonly applied refactorings include:
If many parameters/temporary variables are present:
| 1 | <?php |
||
| 100 | public static function getFunctionCalls($source, $line, $function) |
||
| 101 | { |
||
| 102 | static $up = array( |
||
| 103 | '(' => true, |
||
| 104 | '[' => true, |
||
| 105 | '{' => true, |
||
| 106 | T_CURLY_OPEN => true, |
||
| 107 | T_DOLLAR_OPEN_CURLY_BRACES => true, |
||
| 108 | ); |
||
| 109 | static $down = array( |
||
| 110 | ')' => true, |
||
| 111 | ']' => true, |
||
| 112 | '}' => true, |
||
| 113 | ); |
||
| 114 | static $modifiers = array( |
||
| 115 | '!' => true, |
||
| 116 | '@' => true, |
||
| 117 | '~' => true, |
||
| 118 | '+' => true, |
||
| 119 | '-' => true, |
||
| 120 | ); |
||
| 121 | |||
| 122 | if (KINT_PHP56) { |
||
| 123 | self::$operator[T_POW] = true; |
||
| 124 | self::$operator[T_POW_EQUAL] = true; |
||
| 125 | } |
||
| 126 | |||
| 127 | if (KINT_PHP70) { |
||
| 128 | self::$operator[T_SPACESHIP] = true; |
||
| 129 | } |
||
| 130 | |||
| 131 | $tokens = token_get_all($source); |
||
| 132 | $cursor = 1; |
||
| 133 | $function_calls = array(); |
||
| 134 | $prev_tokens = array(null, null, null); |
||
| 135 | |||
| 136 | if (is_array($function)) { |
||
| 137 | $class = explode('\\', $function[0]); |
||
| 138 | $class = strtolower(end($class)); |
||
| 139 | $function = strtolower($function[1]); |
||
| 140 | } else { |
||
| 141 | $class = null; |
||
| 142 | $function = strtolower($function); |
||
| 143 | } |
||
| 144 | |||
| 145 | // Loop through tokens |
||
| 146 | foreach ($tokens as $index => $token) { |
||
| 147 | if (!is_array($token)) { |
||
| 148 | continue; |
||
| 149 | } |
||
| 150 | |||
| 151 | // Count newlines for line number instead of using $token[2] |
||
| 152 | // since certain situations (String tokens after whitespace) may |
||
| 153 | // not have the correct line number unless you do this manually |
||
| 154 | $cursor += substr_count($token[1], "\n"); |
||
| 155 | if ($cursor > $line) { |
||
| 156 | break; |
||
| 157 | } |
||
| 158 | |||
| 159 | // Store the last real tokens for later |
||
| 160 | if (isset(self::$ignore[$token[0]])) { |
||
| 161 | continue; |
||
| 162 | } else { |
||
| 163 | $prev_tokens = array($prev_tokens[1], $prev_tokens[2], $token); |
||
| 164 | } |
||
| 165 | |||
| 166 | // Check if it's the right type to be the function we're looking for |
||
| 167 | if ($token[0] !== T_STRING || strtolower($token[1]) !== $function) { |
||
| 168 | continue; |
||
| 169 | } |
||
| 170 | |||
| 171 | // Check if it's a function call |
||
| 172 | $nextReal = self::realTokenIndex($tokens, $index); |
||
| 173 | if (!isset($nextReal, $tokens[$nextReal]) || $tokens[$nextReal] !== '(') { |
||
| 174 | continue; |
||
| 175 | } |
||
| 176 | |||
| 177 | // Check if it matches the signature |
||
| 178 | if ($class === null) { |
||
| 179 | if ($prev_tokens[1] && in_array($prev_tokens[1][0], array(T_DOUBLE_COLON, T_OBJECT_OPERATOR))) { |
||
| 180 | continue; |
||
| 181 | } |
||
| 182 | } else { |
||
| 183 | if (!$prev_tokens[1] || $prev_tokens[1][0] !== T_DOUBLE_COLON) { |
||
| 184 | continue; |
||
| 185 | } |
||
| 186 | |||
| 187 | if (!$prev_tokens[0] || $prev_tokens[0][0] !== T_STRING || strtolower($prev_tokens[0][1]) !== $class) { |
||
| 188 | continue; |
||
| 189 | } |
||
| 190 | } |
||
| 191 | |||
| 192 | $inner_cursor = $cursor; |
||
| 193 | $depth = 0; // The depth respective to the function call |
||
| 194 | $offset = 1; // The offset from the function call |
||
| 195 | $instring = false; // Whether we're in a string or not |
||
| 196 | $realtokens = false; // Whether the string contains anything meaningful or not |
||
| 197 | $params = array(); // All our collected parameters |
||
| 198 | $shortparam = array(); // The short version of the parameter |
||
| 199 | $param_start = 1; // The distance to the start of the parameter |
||
| 200 | |||
| 201 | // Loop through the following tokens until the function call ends |
||
| 202 | while (isset($tokens[$index + $offset])) { |
||
| 203 | $token = $tokens[$index + $offset]; |
||
| 204 | |||
| 205 | // Ensure that the $inner_cursor is correct and |
||
| 206 | // that $token is either a T_ constant or a string |
||
| 207 | if (is_array($token)) { |
||
| 208 | $inner_cursor += substr_count($token[1], "\n"); |
||
| 209 | } |
||
| 210 | |||
| 211 | if (!isset(self::$ignore[$token[0]]) && !isset($down[$token[0]])) { |
||
| 212 | $realtokens = true; |
||
| 213 | } |
||
| 214 | |||
| 215 | // If it's a token that makes us to up a level, increase the depth |
||
| 216 | if (isset($up[$token[0]])) { |
||
| 217 | // If this is the first paren set the start of the param to just after it |
||
| 218 | if ($depth === 0) { |
||
| 219 | $param_start = $offset + 1; |
||
| 220 | $realtokens = false; |
||
| 221 | } elseif ($depth === 1) { |
||
| 222 | $shortparam[] = $token; |
||
| 223 | $realtokens = false; |
||
| 224 | } |
||
| 225 | |||
| 226 | ++$depth; |
||
| 227 | } elseif (isset($down[$token[0]])) { |
||
| 228 | --$depth; |
||
| 229 | |||
| 230 | // If this brings us down to the parameter level, and we've had |
||
| 231 | // real tokens since going up, fill the $shortparam with an ellipsis |
||
| 232 | if ($depth === 1) { |
||
| 233 | if ($realtokens) { |
||
| 234 | $shortparam[] = '...'; |
||
| 235 | } |
||
| 236 | $shortparam[] = $token; |
||
| 237 | } |
||
| 238 | } elseif ($token[0] === '"') { |
||
| 239 | // Strings use the same symbol for up and down, but we can |
||
| 240 | // only ever be inside one string, so just use a bool for that |
||
| 241 | if ($instring) { |
||
| 242 | --$depth; |
||
| 243 | if ($depth === 1) { |
||
| 244 | $shortparam[] = '...'; |
||
| 245 | } |
||
| 246 | } else { |
||
| 247 | ++$depth; |
||
| 248 | } |
||
| 249 | |||
| 250 | $instring = !$instring; |
||
| 251 | |||
| 252 | $shortparam[] = '"'; |
||
| 253 | } elseif ($depth === 1) { |
||
| 254 | if ($token[0] === ',') { |
||
| 255 | $params[] = array( |
||
| 256 | 'full' => array_slice($tokens, $index + $param_start, $offset - $param_start), |
||
| 257 | 'short' => $shortparam, |
||
| 258 | ); |
||
| 259 | $shortparam = array(); |
||
| 260 | $param_start = $offset + 1; |
||
| 261 | } elseif ($token[0] === T_CONSTANT_ENCAPSED_STRING && strlen($token[1]) > 2) { |
||
| 262 | $shortparam[] = $token[1][0].'...'.$token[1][0]; |
||
| 263 | } else { |
||
| 264 | $shortparam[] = $token; |
||
| 265 | } |
||
| 266 | } |
||
| 267 | |||
| 268 | // Depth has dropped to 0 (So we've hit the closing paren) |
||
| 269 | if ($depth <= 0) { |
||
| 270 | if ($realtokens) { |
||
| 271 | $params[] = array( |
||
| 272 | 'full' => array_slice($tokens, $index + $param_start, $offset - $param_start), |
||
| 273 | 'short' => $shortparam, |
||
| 274 | ); |
||
| 275 | } |
||
| 276 | |||
| 277 | break; |
||
| 278 | } |
||
| 279 | |||
| 280 | ++$offset; |
||
| 281 | } |
||
| 282 | |||
| 283 | // If we're not passed (or at) the line at the end |
||
| 284 | // of the function call, we're too early so skip it |
||
| 285 | if ($inner_cursor < $line) { |
||
| 286 | continue; |
||
| 287 | } |
||
| 288 | |||
| 289 | // Format the final output parameters |
||
| 290 | foreach ($params as &$param) { |
||
| 291 | $name = self::tokensFormatted($param['short']); |
||
| 292 | $expression = false; |
||
| 293 | foreach ($name as $token) { |
||
| 294 | if (self::tokenIsOperator($token)) { |
||
| 295 | $expression = true; |
||
| 296 | break; |
||
| 297 | } |
||
| 298 | } |
||
| 299 | |||
| 300 | $param = array( |
||
| 301 | 'name' => self::tokensToString($name), |
||
| 302 | 'path' => self::tokensToString(self::tokensTrim($param['full'])), |
||
| 303 | 'expression' => $expression, |
||
| 304 | ); |
||
| 305 | } |
||
| 306 | |||
| 307 | // Get the modifiers |
||
| 308 | $mods = array(); |
||
| 309 | --$index; |
||
| 310 | |||
| 311 | while (isset($tokens[$index])) { |
||
| 312 | if (isset(self::$ignore[$tokens[$index][0]])) { |
||
| 313 | --$index; |
||
| 314 | continue; |
||
| 315 | } elseif (is_array($tokens[$index]) && empty($mods)) { |
||
| 316 | if (isset(self::$identifier[$tokens[$index][0]])) { |
||
| 317 | --$index; |
||
| 318 | continue; |
||
| 319 | } else { |
||
| 320 | break; |
||
| 321 | } |
||
| 322 | } elseif (isset($modifiers[$tokens[$index][0]])) { |
||
| 323 | $mods[] = $tokens[$index]; |
||
| 324 | --$index; |
||
| 325 | continue; |
||
| 326 | } else { |
||
| 327 | break; |
||
| 328 | } |
||
| 329 | } |
||
| 330 | |||
| 331 | $function_calls[] = array( |
||
| 332 | 'parameters' => $params, |
||
| 333 | 'modifiers' => $mods, |
||
| 334 | ); |
||
| 335 | } |
||
| 336 | |||
| 337 | return $function_calls; |
||
| 338 | } |
||
| 339 | |||
| 443 |
Loading history...
This check examines a number of code elements and verifies that they conform to the given naming conventions.
You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods.