/** * Exports the PHP code * * @return string */ public function exportCode() { $modifiers = \Reflection::getModifierNames($this->_method->getModifiers()); $params = array(); // Export method's parameters foreach ($this->_method->getParameters() as $param) { $reflection_parameter = new ReflectionParameter($param); $params[] = $reflection_parameter->exportCode(); } return sprintf('%s function %s(%s) {}', join(' ', $modifiers), $this->_method->getName(), join(', ', $params)); }
public function writeMethod(\ReflectionMethod $method) { $args = []; foreach ($method->getParameters() as $parameter) { $arg = ''; if ($parameter->isArray()) { $arg .= 'array '; } else { if ($parameter->getClass()) { $arg .= '\\' . $parameter->getClass()->getName() . ' '; } } if ($parameter->isPassedByReference()) { $arg .= '&'; } $arg .= '$' . $parameter->getName(); try { $defaultValue = $parameter->getDefaultValue(); $arg .= ' = ' . var_export($defaultValue, true); } catch (ReflectionException $e) { if ($parameter->isOptional()) { $arg .= ' = null'; } } $args[] = $arg; } $modifiers = array_diff(\Reflection::getModifierNames($method->getModifiers()), ['abstract']); $methodName = ($method->returnsReference() ? '&' : '') . $method->getName(); $this->code[] = ' ' . implode(' ', $modifiers) . ' function ' . $methodName . '(' . implode(', ', $args) . ') {'; $this->code[] = ' $result = $this->' . $this->propertyName . '->invoke($this, \'' . $method->getName() . '\', func_get_args());'; $this->code[] = ' return $result;'; $this->code[] = ' }'; }
/** * Returns a bitfield of the access modifiers for this method * * @return integer Bitfield of the access modifiers for this method */ public function getModifiers() { if ($this->reflectionSource instanceof ReflectionMethod) { return $this->reflectionSource->getModifiers(); } else { return parent::getModifiers(); } }
/** * @return Method[] */ public static function methodListFromReflectionClassAndMethod(Context $context, CodeBase $code_base, \ReflectionClass $class, \ReflectionMethod $reflection_method) : array { $reflection_method = new \ReflectionMethod($class->getName(), $reflection_method->name); $method = new Method($context, $reflection_method->name, new UnionType(), $reflection_method->getModifiers()); $method->setNumberOfRequiredParameters($reflection_method->getNumberOfRequiredParameters()); $method->setNumberOfOptionalParameters($reflection_method->getNumberOfParameters() - $reflection_method->getNumberOfRequiredParameters()); $method->setFQSEN(FullyQualifiedMethodName::fromStringInContext($method->getName(), $context)); return self::functionListFromFunction($method, $code_base); }
/** * @param ReflectionMethod[] $methods */ private function checkMethodsInNewClasses($methods) { foreach ($methods as $method) { list($expectedMethod, $class) = $this->explodeCamel($method->getName()); $this->assertTrue(method_exists($class, $expectedMethod), 'Method ' . $expectedMethod . ' is not found in class ' . $class); $newMethod = new ReflectionMethod($class, $expectedMethod); $this->assertEquals($method->getModifiers(), $newMethod->getModifiers(), 'Incorrect modifier for ' . $class . '::' . $expectedMethod); $this->assertEquals(substr_count(file_get_contents($method->getFileName()), $method->getName()), substr_count(file_get_contents($newMethod->getFileName()), $newMethod->getName()), 'Incorrect usage for ' . $class . '::' . $expectedMethod); } }
/** * {@inheritdoc} * @throws MethodDefinitionAlreadyExistsException * @throws MethodDefinitionNotFoundException */ public function analyze(DefinitionAnalyzer $analyzer, ClassDefinition $classDefinition, \ReflectionMethod $reflectionMethod) { $methodName = $reflectionMethod->getName(); // Constructor definition is required if ($methodName === '__construct' && !$classDefinition->hasMethod('__construct')) { $classDefinition->defineConstructor()->end(); } // Set method metadata if ($classDefinition->hasMethod($methodName)) { $classDefinition->getMethod($methodName)->setModifiers($reflectionMethod->getModifiers())->setIsPublic($reflectionMethod->isPublic()); } }
/** * @param ReflectionMethod $method * @return int */ private function getMethodModifier($method) { switch ($method->getModifiers()) { case '134283520': return self::PUBLIC_MODIFIER; case '134283776': return self::PROTECTED_MODIFIER; case '134284288': return self::PRIVATE_MODIFIER; default: return self::PUBLIC_MODIFIER; } }
public function __construct($class, $method) { $method = new ReflectionMethod($class, $method); $this->name = $method->name; $class = $parent = $method->getDeclaringClass(); if ($modifiers = $method->getModifiers()) { $this->modifiers = '<small>' . implode(' ', Reflection::getModifierNames($modifiers)) . '</small> '; } $comment = ''; do { if ($parent->hasMethod($this->name)) { $comment = $parent->getMethod($this->name)->getDocComment(); // Found a description for this method break; } } while ($parent = $parent->getParentClass()); list($this->description, $tags) = Kodoc::parse($comment); if ($file = $class->getFileName()) { $this->source = Kodoc::source($file, $method->getStartLine(), $method->getEndLine()); } if (isset($tags['param'])) { $params = array(); foreach ($method->getParameters() as $i => $param) { $param = new Kodoc_Method_Param(array($method->class, $method->name), $i); if (isset($tags['param'][$i])) { if (preg_match('/^(\\S*)\\s*(\\$\\w+)?(?:\\s*(.+?))?$/', $tags['param'][$i], $matches)) { $param->type = $matches[1]; $param->description = arr::get($matches, 3); } } $params[] = $param; } $this->params = $params; unset($tags['param']); } if (isset($tags['return'])) { foreach ($tags['return'] as $return) { if (preg_match('/^(\\S*)(?:\\s*(.+?))?$/', $return, $matches)) { $this->return[] = array($matches[1], isset($matches[2]) ? $matches[2] : ''); } } unset($tags['return']); } $this->tags = $tags; }
/** * Generic class method resolver. * * @param \ReflectionMethod $method * @param ClassMetadata $classMetadata * * @return MethodMetadata Resolved method metadata */ protected function resolveMethodMetadata(\ReflectionMethod $method, ClassMetadata $classMetadata) : MethodMetadata { // Create method metadata instance $methodMetadata = $classMetadata->methodsMetadata[$method->name] ?? new MethodMetadata($classMetadata); $methodMetadata->name = $method->name; $methodMetadata->modifiers = $method->getModifiers(); $methodMetadata->isPublic = $method->isPublic(); /** @var \ReflectionParameter $parameter */ $parameterMetadata = new ParameterMetadata($classMetadata, $methodMetadata); foreach ($method->getParameters() as $parameter) { $parameterMetadata = $methodMetadata->parametersMetadata[$parameter->name] ?? clone $parameterMetadata; $parameterMetadata->name = $parameter->name; $parameterMetadata->typeHint = (string) $parameter->getType(); // Store parameters metadata in method metadata $methodMetadata->parametersMetadata[$parameterMetadata->name] = $parameterMetadata; } // Store method metadata in class metadata return $classMetadata->methodsMetadata[$methodMetadata->name] = $methodMetadata; }
function add_class($class_name, $flags) { global $classes, $internal_arginfo; $lc = strtolower($class_name); $class = new \ReflectionClass($class_name); if ($class->isFinal()) { $flags |= \ast\flags\CLASS_FINAL; } if ($class->isAbstract()) { $flags |= \ast\flags\CLASS_ABSTRACT; } $classes[$lc] = ['file' => 'internal', 'conditional' => false, 'flags' => $flags, 'lineno' => 0, 'endLineno' => 0, 'name' => $class_name, 'docComment' => '', 'traits' => []]; foreach ($class->getDefaultProperties() as $name => $value) { $prop = new \ReflectionProperty($class_name, $name); $classes[$lc]['properties'][strtolower($name)] = ['flags' => $prop->getModifiers(), 'name' => $name, 'lineno' => 0, 'value' => $value]; } foreach ($class->getConstants() as $name => $value) { $classes[$lc]['constants'][strtolower($name)] = ['name' => $name, 'lineno' => 0, 'value' => $value]; } foreach ($class->getMethods() as $method) { $meth = new \ReflectionMethod($class_name, $method->name); $required = $meth->getNumberOfRequiredParameters(); $optional = $meth->getNumberOfParameters() - $required; $lmname = strtolower($method->name); $classes[$lc]['methods'][$lmname] = ['file' => 'internal', 'conditional' => false, 'flags' => $meth->getModifiers(), 'lineno' => 0, 'endLineno' => 0, 'name' => $method->name, 'docComment' => '', 'required' => $required, 'optional' => $optional, 'ret' => null]; $arginfo = null; if (!empty($internal_arginfo["{$class_name}::{$method->name}"])) { $arginfo = $internal_arginfo["{$class_name}::{$method->name}"]; $classes[$lc]['methods'][$lmname]['ret'] = $arginfo[0]; } foreach ($method->getParameters() as $param) { $flags = 0; if ($param->isPassedByReference()) { $flags |= \ast\flags\PARAM_REF; } if ($param->isVariadic()) { $flags |= \ast\flags\PARAM_VARIADIC; } $classes[$lc]['methods'][strtolower($method->name)]['params'][] = ['file' => 'internal', 'flags' => $flags, 'lineno' => 0, 'name' => $param->name, 'type' => empty($arginfo) ? null : next($arginfo), 'def' => null]; } } }
function writeMethod(ReflectionMethod $method, ReflectionClass $class) { if ($method->getDeclaringClass() != $class) { return ""; } $acc = $method->getModifiers(); $func = ""; if ($acc & ReflectionMethod::IS_STATIC) { $func .= "static "; } if ($acc & ReflectionMethod::IS_ABSTRACT) { $func .= "abstract "; } if ($acc & ReflectionMethod::IS_FINAL) { $func .= "final "; } if ($acc & ReflectionMethod::IS_PUBLIC) { $func .= "public "; } if ($acc & ReflectionMethod::IS_PROTECTED) { $func .= "protected "; } if ($acc & ReflectionMethod::IS_PRIVATE) { $func .= "private "; } $data = methodData($method); $params = $data[1]; if (empty($params)) { $refparams = $method->getParameters(); if (!empty($refparams)) { foreach ($refparams as $param) { $params[] = "\$" . $param->name; } } else { for ($i = 0; $i < $method->getNumberOfParameters(); $i++) { $params[] = "\$arg{$i}"; } } } $params = join(",", $params); return "{$data['0']}{$func}function {$method->name}({$params}) {}\n"; }
function getMethod() { $method_call = ''; if (!$this->hasClassName()) { if ($this->hasFuncName()) { $method_call = $this->funcName(); } //if } else { if (!$this->hasFuncName()) { $method_call = $this->className(); } else { $class = $this->className(); $method = $this->funcName(); $method_reflect = new ReflectionMethod($class, $method); $method_modifiers = join(' ', Reflection::getModifierNames($method_reflect->getModifiers())); $method_caller = '->'; if (mb_stripos($method_modifiers, 'static') !== false) { $method_caller = '::'; } //if $method_call = sprintf('%s %s%s%s', $method_modifiers, $class, $method_caller, $method); } //if/else } //if/else $method_args = ''; if ($this->hasFuncArgs()) { $arg_list = array(); foreach ($this->funcArgs() as $arg) { if (is_object($arg)) { $arg_list[] = get_class($arg); } else { if (is_array($arg)) { $arg_list[] = sprintf('Array(%s)', count($arg)); } else { if (is_bool($arg)) { $arg_list[] = $arg ? 'TRUE' : 'FALSE'; } else { if (is_null($arg)) { $arg_list[] = 'NULL'; } else { if (is_string($arg)) { $arg_list[] = sprintf('"%s"', $arg); } else { $arg_list[] = $arg; } } } } //if/else } //if/else } //foreach $method_args = join(', ', $arg_list); } //if return sprintf('%s(%s)', $method_call, $method_args); }
/** * @return Method[] */ public static function methodListFromReflectionClassAndMethod(Context $context, CodeBase $code_base, \ReflectionClass $class, \ReflectionMethod $method) : array { $reflection_method = new \ReflectionMethod($class->getName(), $method->name); $number_of_required_parameters = $reflection_method->getNumberOfRequiredParameters(); $number_of_optional_parameters = $reflection_method->getNumberOfParameters() - $number_of_required_parameters; $method = new Method($context, $method->name, new UnionType(), $reflection_method->getModifiers(), $number_of_required_parameters, $number_of_optional_parameters); return self::methodListFromMethod($method, $code_base); }
} catch (TypeError $re) { echo "Ok - " . $re->getMessage() . PHP_EOL; } try { new ReflectionMethod('a', 'b', 'c'); } catch (TypeError $re) { echo "Ok - " . $re->getMessage() . PHP_EOL; } class C { public function f() { } } $rm = new ReflectionMethod('C', 'f'); var_dump($rm->isFinal(1)); var_dump($rm->isAbstract(1)); var_dump($rm->isPrivate(1)); var_dump($rm->isProtected(1)); var_dump($rm->isPublic(1)); var_dump($rm->isStatic(1)); var_dump($rm->isConstructor(1)); var_dump($rm->isDestructor(1)); var_dump($rm->getModifiers(1)); var_dump($rm->isInternal(1)); var_dump($rm->isUserDefined(1)); var_dump($rm->getFileName(1)); var_dump($rm->getStartLine(1)); var_dump($rm->getEndLine(1)); var_dump($rm->getStaticVariables(1)); var_dump($rm->getName(1));
/** * Finds the visibility of a ReflectionMethod. * * @param object ReflectionMethod * @return string */ protected function visibility(ReflectionMethod $method) { $vis = array_flip(Reflection::getModifierNames($method->getModifiers())); if (isset($vis['public'])) { return 'public'; } if (isset($vis['protected'])) { return 'protected'; } if (isset($vis['private'])) { return 'private'; } return FALSE; }
function create_markup_to_modifiers(ReflectionMethod $method) { /* {{{ */ $modifiers = Reflection::getModifierNames($method->getModifiers()); $markup = ''; if ($modifiers) { foreach ($modifiers as $modifier) { $markup .= '<modifier>' . $modifier . '</modifier> '; } } return $markup; }
/** * Is this a testable method? * * @param string $className Class name * @param \ReflectionMethod $reflectionMethod Reflection method * * @return boolean False if method should not be counted */ protected function isTestableMethod($className, $reflectionMethod) { $method = $reflectionMethod->getName(); $modifiers = $reflectionMethod->getModifiers(); if ($method === $className || $modifiers !== \ReflectionMethod::IS_PUBLIC || in_array($method, self::$magicMethods)) { return false; } return true; }
/** * Create a syntax highlighted diagram of class functions, and optionally the current output of each method. * Only use the autofire if you are sure ALL METHODS perform a non-permanent functions. * * --== WARNING, USING AUTOFIRE IS DANGEROUS AND CAN DESTROY DATA PERMANENTLY ==-- * * For instance, autofiring a function called delete_all_users() ...will do exactly that! * * You have been warned! * * @param object $obj The object to explore. * @param boolean $autofire Fire each method, to acertain its current return value. * @return [type] [description] */ public static function methods($obj, $autofire = false) { echo self::$is_themed ? '' : self::$theme; $methods = get_class_methods($obj); asort($methods); echo "<pre class='obj_explorer'>" . PHP_EOL; self::classes($obj); $cnt = 0; foreach ($methods as $m) { echo "<div class='method'>"; $fnc = new \ReflectionMethod($obj, $m); $num = $fnc->getNumberOfParameters(); $req = $fnc->getNumberOfRequiredParameters(); $arg = $fnc->getParameters(); $mod = implode(' ', \Reflection::getModifierNames($fnc->getModifiers())) . ' '; $lin = self::get_func_url($fnc->getStartLine(), $fnc->getEndLine(), $fnc->getFileName()); $exp = $fnc->getEndLine(); $dbk = $fnc->getDocComment(); $nam = "function <b id='{$m}' class='nam'>{$m}</b>"; # Parse method arguments if ($num > 0) { $arg = implode($arg, ', '); preg_match_all('/\\[(.*?)\\]/', $arg, $arg); $arg = implode($arg[1], ','); # Remove optional required tags $arg = preg_replace('/<required>|<optional>|<head>/', "", $arg); # Strip double spaces $arg = preg_replace('/\\s+/', "", $arg); # Add nice spacing $arg = preg_replace('/,/', ', ', $arg); # Add Function brackets $arg = "({$arg})"; } else { # No arguments with this function, empty brackets $arg = '()'; } # Completed function string $function = $mod . $nam . $arg; # Docblock $dbk = self::clean_docblok($dbk); # Convert tabs to space $dbk = preg_replace('/\\t+/', ' ', $dbk); # Realign offset offset docbloks $dbk = preg_replace('/\\s\\s+\\*/', "\n *", $dbk); # Completed docblok string $dokblock = $dbk; # Return Defaults $result = 'autofire disabled '; $type = 'safemode'; # Parse return value if ($autofire) { if ($req) { $result = "<b class='com'>...Untested {$req} required argument(s) needed</b>"; } else { $result = $obj->{$m}(); $type = gettype($result); if ($type === "boolean") { $type = AlpStrings::boolstr($result); $result = ''; } if ($type === "integer") { } if ($type === "double") { } if ($type === "string") { $result = "'{$result}'"; } if ($type === "array") { $result = PHP_EOL . PHP_EOL . '{ARR}' . print_r($result, true) . '{/ARR}'; } if ($type === "object") { $result = 'object'; #recurse! } if ($type === "resource") { $result = $type; } if ($type === "NULL") { $result = "<b class='com'>...Check page src for possible function echo</b>"; } if ($type === "unknown type") { $result = $type; } } } #divider and Line Info # Completed return string $result = "<b class='ops'>" . trim("Returned </b>(<b class='dec'>{$type}</b>)") . " {$result}"; $method_info = $dokblock . PHP_EOL . PHP_EOL . $function . PHP_EOL . PHP_EOL . $result; $method_info = Syntax::php($method_info, 'all'); echo $lin; echo $method_info; echo "</div>"; } echo '</pre>'; return; /* #echo implode(' ', Reflection::getModifierNames($fnc->getModifiers())).PHP_EOL; #echo 'getParameters() : '.print_r( $fnc->getParameters()).PHP_EOL; #echo 'getStaticVariables() : '.print_r( $fnc->getStaticVariables()).PHP_EOL; #echo 'isAbstract() : '.AT::boolstr( $fnc->isAbstract()).PHP_EOL; #echo 'isConstructor() : '.AT::boolstr( $fnc->isConstructor()).PHP_EOL; #echo 'isDestructor() : '.AT::boolstr( $fnc->isDestructor()).PHP_EOL; #echo 'isFinal() : '.AT::boolstr( $fnc->isFinal()).PHP_EOL; #echo 'isPrivate() : '.AT::boolstr( $fnc->isPrivate()).PHP_EOL; #echo 'isProtected() : '.AT::boolstr( $fnc->isProtected()).PHP_EOL; #echo 'isPublic() : '.AT::boolstr( $fnc->isPublic()).PHP_EOL; #echo 'isStatic() : '.AT::boolstr( $fnc->isStatic()).PHP_EOL; #echo 'inNamespace() : '.AT::boolstr( $fnc->inNamespace()).PHP_EOL; #echo 'isClosure() : '.AT::boolstr( $fnc->isClosure()).PHP_EOL; #echo 'isDeprecated() : '.AT::boolstr( $fnc->isDeprecated()).PHP_EOL; #echo 'isGenerator() : '.AT::boolstr( $fnc->isGenerator()).PHP_EOL; #echo 'isInternal() : '.AT::boolstr( $fnc->isInternal()).PHP_EOL; #echo 'isUserDefined() : '.AT::boolstr( $fnc->isUserDefined()).PHP_EOL; #echo 'returnsReference() : '.AT::boolstr( $fnc->returnsReference()).PHP_EOL; #echo 'Name : '. $fnc->name.PHP_EOL; #echo 'Class : '. $fnc->class.PHP_EOL; #echo 'getModifiers() : '. implode(' ', Reflection::getModifierNames($fnc->getModifiers())).PHP_EOL; #echo 'getEndLine() : '. $fnc->getEndLine().PHP_EOL; #echo 'getNumberOfParameters() : '. $fnc->getNumberOfParameters().PHP_EOL; #echo 'getNumberOfRequiredParameters() : '. $fnc->getNumberOfRequiredParameters().PHP_EOL; #echo 'getStartLine() : '. $fnc->getStartLine().PHP_EOL; #echo 'getDocComment() : '. $fnc->getDocComment().PHP_EOL; #echo 'getExtensionName() : '. $fnc->getExtensionName().PHP_EOL; #echo 'getFileName() : '. $fnc->getFileName().PHP_EOL; #echo 'getName() : '. $fnc->getName().PHP_EOL; #echo 'getNamespaceName() : '. $fnc->getNamespaceName().PHP_EOL; #echo 'getShortName() : '. $fnc->getShortName().PHP_EOL; */ }
/** * @param \ReflectionMethod $reflectedMethod * * @return string */ protected function documentMethodSignature(\ReflectionMethod $reflectedMethod) { if ($this->processMethodSignature === false) { return ""; } $modifiers = implode(' ', \Reflection::getModifierNames($reflectedMethod->getModifiers())); $params = implode(', ', array_map(function ($p) { return $this->documentParam($p); }, $reflectedMethod->getParameters())); $signature = "#### *{$modifiers}* {$reflectedMethod->name}({$params})"; if (is_callable($this->processMethodSignature)) { $signature = call_user_func($this->processMethodSignature, $reflectedMethod, $signature); } return $signature; }
class Counter { private static $c = 0; /** * Increment counter * * @final * @static * @access public * @return int */ public static final function increment() { return ++self::$c; } } // Create an instance of the ReflectionMethod class $method = new ReflectionMethod('Counter', 'increment'); // Print out basic information printf("===> The %s%s%s%s%s%s%s method '%s' (which is %s)\n" . " declared in %s\n" . " lines %d to %d\n" . " having the modifiers %d[%s]\n", $method->isInternal() ? 'internal' : 'user-defined', $method->isAbstract() ? ' abstract' : '', $method->isFinal() ? ' final' : '', $method->isPublic() ? ' public' : '', $method->isPrivate() ? ' private' : '', $method->isProtected() ? ' protected' : '', $method->isStatic() ? ' static' : '', $method->getName(), $method->isConstructor() ? 'the constructor' : 'a regular method', $method->getFileName(), $method->getStartLine(), $method->getEndline(), $method->getModifiers(), implode(' ', Reflection::getModifierNames($method->getModifiers()))); echo "\n"; // Print documentation comment printf("---> Documentation:\n %s\n", var_export($method->getDocComment(), 1)); // Print static variables if existant if ($statics = $method->getStaticVariables()) { printf("---> Static variables: %s\n", var_export($statics, 1)); } echo "\n"; // Invoke the method printf("---> Invocation results in: "); var_dump($method->invoke(NULL));
private function getMethodData(ReflectionMethod $reflectionMethod, $classContent, &$classData) { //TODO: parse local variable $modifiers = Reflection::getModifierNames($reflectionMethod->getModifiers()); $startLine = $reflectionMethod->getStartLine(); $endLine = $reflectionMethod->getEndline(); $parameters = $reflectionMethod->getParameters(); $docComment = $reflectionMethod->getDocComment(); if (!$docComment) { $docComment = ""; } $parsedComment = $this->parseDocComment($docComment, 'method'); $out = array(); $out['params'] = array(); $out['docComment'] = $this->trimDocComment($docComment); $out['inheritdoc'] = $parsedComment['inheritdoc']; $out['startLine'] = $startLine; $out['endLine'] = $endLine; $origin = $reflectionMethod->getDeclaringClass()->getFileName() == false ? "" : $reflectionMethod->getDeclaringClass()->getFileName(); $origin = $this->normalizePath($origin); $out['origin'] = $origin; $params = array(); foreach ($parameters as $parameter) { $parameterName = '$' . $parameter->getName(); try { $parameterClass = $parameter->getClass(); } catch (\Exception $e) { $parameterClass = ""; } $parameterType = ""; //not defined try to find in the doccomment if (empty($parameterClass)) { if (array_key_exists($parameterName, $parsedComment['params'])) { $parameterType = $parsedComment['params'][$parameterName]; } } else { $parameterType = $parameter->getClass()->getName(); } $params[] = $parameterType . ' ' . $parameterName; $out['params'][$parameterName] = $parameterType; } if (array_key_exists('return', $parsedComment) && $parsedComment['return'] != "") { $returnType = ""; $arrayReturn = 0; $returnTypes = explode('|', trim($parsedComment['return'])); foreach ($returnTypes as $rType) { if (preg_match('/\\[\\]$/', $rType)) { $arrayReturn = 1; $rType = trim($rType, "[]"); } if (!$this->isScalar($rType)) { $returnType = $rType; if ($returnType[0] == '\\') { $returnType = substr($returnType, 1); } break; } } if (empty($returnType)) { $out['return'] = ""; } else { $out['return'] = $this->guessClass($returnType, $classData['namespaces']); } $out['array_return'] = $arrayReturn; } $return = empty($parsedComment['return']) ? "none" : $parsedComment['return']; $out['signature'] = '(' . join(', ', $params) . ') : ' . $return; foreach ($modifiers as $modifier) { $classData['methods']['modifier'][$modifier][] = $reflectionMethod->name; } $classData['methods']['all'][$reflectionMethod->name] = $out; }
public function methods($control) { $methods = array(); $controller = APPPATH . 'controllers/' . $control . '.php'; if (file_exists($controller)) { include $controller; if (class_exists($control, FALSE)) { $controller = new $control(); foreach (get_class_methods($controller) as $method) { if (!in_array($method, $this->system)) { $m = new ReflectionMethod($control, $method); $r = Reflection::getModifierNames($m->getModifiers()); if (in_array('public', $r)) { $methods[] = $method; } } } } } return $methods; }
/** * Creates the implementation of a single method * * @param ReflectionMethod $method * * @return string */ protected function implementMethod(ReflectionMethod $method) { $modifiers = implode(' ', Reflection::getModifierNames($method->getModifiers() & ~ReflectionMethod::IS_ABSTRACT)); $reference = $method->returnsReference() ? '&' : ''; $methodDef = "\n\t{$modifiers} function {$reference}{$method->getName()}({$this->generateMethodParameters($method)})\n\t{\n\t\t\$args = array();\n\t\t{$this->copyMethodParameters($method)}\n\t\t\n\t\t\$funcArgs = func_get_args();\n\t\t\$answer = \$this->__PHAKE_handlerChain->invoke(\$this, '{$method->getName()}', \$funcArgs, \$args);\n\t\t\n\t\tif (\$answer instanceof Phake_Stubber_Answers_IDelegator)\n\t\t{\n\t\t\t\$delegate = \$answer->getAnswer();\n\t\t\t\$callback = \$delegate->getCallBack(\$this, '{$method->getName()}', \$args);\n\t\t\t\$arguments = \$delegate->getArguments('{$method->getName()}', \$args);\n\n\t\t\t\$realAnswer = call_user_func_array(\$callback, \$arguments);\n\t\t\t\$answer->processAnswer(\$realAnswer);\n\t\t\treturn \$realAnswer;\n\t\t}\n\t\telse\n\t\t{\n\t\t\t\$returnAnswer = \$answer->getAnswer();\n\t\t\treturn \$returnAnswer;\n\t\t}\n\t}\n"; return $methodDef; }
<pre> <?php class Counter { private static $c = 0; public static final function increment() { return ++self::$c; } } // Создание экземпляра класса ReflectionMethod $method = new ReflectionMethod('Counter', 'increment'); // exit; // Вывод основной информации printf("===> %s%s%s%s%s%s%s метод '%s' (который является %s)\n" . " объявлен в %s\n" . " строки с %d по %d\n" . " имеет модификаторы %d[%s]\n", $method->isInternal() ? 'Встроенный' : 'Пользовательский', $method->isAbstract() ? ' абстрактный' : '', $method->isFinal() ? ' финальный' : '', $method->isPublic() ? ' public' : '', $method->isPrivate() ? ' private' : '', $method->isProtected() ? ' protected' : '', $method->isStatic() ? ' статический' : '', $method->getName(), $method->isConstructor() ? 'конструктором' : 'обычным методом', $method->getFileName(), $method->getStartLine(), $method->getEndline(), $method->getModifiers(), implode(' ', Reflection::getModifierNames($method->getModifiers()))); // Вывод статических переменных, если они есть if ($statics = $method->getStaticVariables()) { printf("---> Статическая переменная: %s\n", var_export($statics, 1)); } // Вызов метода printf("---> Результат вызова: "); $result = $method->invoke(3); echo $result; ?> </pre>
private function GenerateOverridingMethodTemplate(\ReflectionMethod $EntityMethod) { $MethodTemplate = self::OverriddenMethodTemplate; $Modifiers = \Reflection::getModifierNames($EntityMethod->getModifiers()); $Modifiers[] = 'function'; if ($EntityMethod->returnsReference()) { $Modifiers[] = '&'; } $Modifiers = implode(' ', $Modifiers); $Name = $EntityMethod->getName(); $Parameters = []; $ParameterVariables = []; foreach ($EntityMethod->getParameters() as $Parameter) { $ParameterVariables[] = '$' . $Parameter->getName(); $Parameters[] = $this->GenerateMethodParameter($Parameter); } $Parameters = implode(', ', $Parameters); $ParameterVariables = implode(', ', $ParameterVariables); $MethodTemplate = str_replace('<Modifiers>', $Modifiers, $MethodTemplate); $MethodTemplate = str_replace('<Name>', $Name, $MethodTemplate); $MethodTemplate = str_replace('<Parameters>', $Parameters, $MethodTemplate); $MethodTemplate = str_replace('<ParameterVariables>', $ParameterVariables, $MethodTemplate); return $MethodTemplate; }
/** * Creates a method code from Reflection * * @param Method|ParsedMethod $method Reflection for method * @param string $body Body of method * * @return string */ protected function getOverriddenMethod($method, $body) { $code = preg_replace('/ {4}|\\t/', '', $method->getDocComment()) . "\n" . join(' ', Reflection::getModifierNames($method->getModifiers())) . ' function ' . ($method->returnsReference() ? '&' : '') . $method->name . '(' . join(', ', $this->getParameters($method->getParameters())) . ")\n" . "{\n" . $this->indent($body) . "\n" . "}\n"; return $code; }
function add_class($class_name) { global $classes, $internal_arginfo, $internal_classvars; $lc = strtolower($class_name); $class = new \ReflectionClass($class_name); $flags = 0; if ($class->isFinal()) { $flags = \ast\flags\CLASS_FINAL; } else { if ($class->isInterface()) { $flags = \ast\flags\CLASS_INTERFACE; } else { if ($class->isTrait()) { $flags = \ast\flags\CLASS_TRAIT; } } } if ($class->isAbstract()) { $flags |= \ast\flags\CLASS_ABSTRACT; } $classes[$lc] = ['file' => 'internal', 'namespace' => $class->getNamespaceName(), 'conditional' => false, 'flags' => $flags, 'lineno' => 0, 'endLineno' => 0, 'name' => $class_name, 'docComment' => '', 'type' => '', 'traits' => []]; $parent = $class->getParentClass(); if (!$parent) { $classes[$lc]['parent'] = ''; } else { $classes[$lc]['parent'] = $parent->getName(); } foreach ($class->getDefaultProperties() as $name => $value) { $type = $internal_classvars[strtolower($class_name)]['properties'][$name] ?? type_map(gettype($value)); # echo "{$class_name}::{$name} = ($type) $value\n"; $prop = new \ReflectionProperty($class_name, $name); $classes[$lc]['properties'][strtolower($name)] = ['flags' => $prop->getModifiers(), 'name' => $name, 'lineno' => 0, 'type' => type_map(gettype($value))]; } $classes[$lc]['interfaces'] = $class->getInterfaceNames(); $classes[$lc]['traits'] = $class->getTraitNames(); $parents = []; $parent = $class->getParentClass(); if ($parent) { $temp = $class; while ($parent = $temp->getParentClass()) { $parents[] = $parent->getName(); $parents = array_merge($parents, $parent->getInterfaceNames()); $temp = $parent; } } $types = [$class_name]; $types = array_merge($types, $classes[$lc]['interfaces']); $types = array_merge($types, $parents); $classes[$lc]['type'] = implode('|', array_unique($types)); foreach ($class->getConstants() as $name => $value) { $classes[$lc]['constants'][$name] = ['name' => $name, 'lineno' => 0, 'type' => type_map(gettype($value))]; } foreach ($class->getMethods() as $method) { $meth = new \ReflectionMethod($class_name, $method->name); $required = $meth->getNumberOfRequiredParameters(); $optional = $meth->getNumberOfParameters() - $required; $lmname = strtolower($method->name); $classes[$lc]['methods'][$lmname] = ['file' => 'internal', 'namespace' => $class->getNamespaceName(), 'conditional' => false, 'flags' => $meth->getModifiers(), 'lineno' => 0, 'endLineno' => 0, 'name' => $method->name, 'docComment' => '', 'required' => $required, 'optional' => $optional, 'ret' => null]; $arginfo = []; unset(${"arginfo1"}); $alt = 1; if (!empty($internal_arginfo["{$class_name}::{$method->name}"])) { $arginfo = $internal_arginfo["{$class_name}::{$method->name}"]; $classes[$lc]['methods'][$lmname]['ret'] = $arginfo[0]; while (!empty($internal_arginfo["{$class_name}::{$method->name} {$alt}"])) { $classes[$lc]['methods']["{$lmname} {$alt}"] = $classes[$lc]['methods'][$lmname]; ${"arginfo{$alt}"} = $internal_arginfo["{$class_name}::{$method->name} {$alt}"]; unset(${"arginfo" . ($alt + 1)}); $classes[$lc]['methods']["{$lmname} {$alt}"]['ret'] = ${"arginfo{$alt}"}[0]; $alt++; } } else { if (!empty($parents)) { foreach ($parents as $parent_name) { if (!empty($internal_arginfo["{$parent_name}::{$method->name}"])) { $classes[$lc]['methods']["{$lmname} {$alt}"] = $classes[$lc]['methods'][$lmname]; $arginfo = $internal_arginfo["{$parent_name}::{$method->name}"]; $classes[$lc]['methods'][$lmname]['ret'] = $arginfo[0]; while (!empty($internal_arginfo["{$parent_name}::{$method->name} {$alt}"])) { ${"arginfo{$alt}"} = $internal_arginfo["{$parent_name}::{$method->name} {$alt}"]; unset(${"arginfo" . ($alt + 1)}); $classes[$lc]['methods']["{$lmname} {$alt}"]['ret'] = ${"arginfo{$alt}"}[0]; $alt++; } break; } } } } foreach ($method->getParameters() as $param) { $alt = 1; $flags = 0; if ($param->isPassedByReference()) { $flags |= \ast\flags\PARAM_REF; } if ($param->isVariadic()) { $flags |= \ast\flags\PARAM_VARIADIC; } $classes[$lc]['methods'][strtolower($method->name)]['params'][] = ['file' => 'internal', 'flags' => $flags, 'lineno' => 0, 'name' => $param->name, 'type' => empty($arginfo) ? null : next($arginfo), 'def' => null]; while (!empty(${"arginfo{$alt}"})) { $classes[$lc]['methods'][strtolower($method->name) . ' ' . $alt]['params'][] = ['file' => 'internal', 'flags' => $flags, 'lineno' => 0, 'name' => $param->name, 'type' => empty(${"arginfo{$alt}"}) ? null : next(${"arginfo{$alt}"}), 'def' => null]; $alt++; } } } }
/** * Creates the implementation of a single method * * @param ReflectionMethod $method * * @return string */ protected function implementMethod(ReflectionMethod $method, $static = false) { $modifiers = implode(' ', Reflection::getModifierNames($method->getModifiers() & ~ReflectionMethod::IS_ABSTRACT)); $reference = $method->returnsReference() ? '&' : ''; if ($static) { $context = '__CLASS__'; } else { $context = '$this'; } $docComment = $method->getDocComment() ?: ''; $methodDef = "\n\t{$docComment}\n\t{$modifiers} function {$reference}{$method->getName()}({$this->generateMethodParameters($method)})\n\t{\n\t\t\$__PHAKE_args = array();\n\t\t{$this->copyMethodParameters($method)}\n\n \$__PHAKE_info = Phake::getInfo({$context});\n\t\tif (\$__PHAKE_info === null) {\n\t\t return null;\n\t\t}\n\n\t\t\$__PHAKE_funcArgs = func_get_args();\n\t\t\$__PHAKE_answer = \$__PHAKE_info->getHandlerChain()->invoke({$context}, '{$method->getName()}', \$__PHAKE_funcArgs, \$__PHAKE_args);\n\n\t \$__PHAKE_callback = \$__PHAKE_answer->getAnswerCallback({$context}, '{$method->getName()}');\n\t \$__PHAKE_result = call_user_func_array(\$__PHAKE_callback, \$__PHAKE_args);\n\t \$__PHAKE_answer->processAnswer(\$__PHAKE_result);\n\t return \$__PHAKE_result;\n\t}\n"; return $methodDef; }
public static function castMethod(\ReflectionMethod $c, array $a, Stub $stub, $isNested) { $a[Caster::PREFIX_VIRTUAL . 'modifiers'] = implode(' ', \Reflection::getModifierNames($c->getModifiers())); return $a; }
/** * @param string|object $class * @param string $method * * @return int */ private static function getModifiers($class, $method) { $reflectionClass = new \ReflectionClass($class); /** * @var \ReflectionClass $reflectionInterfaces */ $reflectionInterfaces = $reflectionClass->getInterfaces(); $isInterfaceMethod = 0; foreach ($reflectionInterfaces as $reflectionInterface) { if ($reflectionInterface->hasMethod($method)) { $isInterfaceMethod = 1; } } $topMostClass = self::getTopMostClass($reflectionClass); $isAbstractMethod = 0; if ($topMostClass->isAbstract() && $topMostClass->hasMethod($method)) { $isAbstractMethod = 2; } $reflectionMethod = new \ReflectionMethod($class, $method); $visibility = $reflectionMethod->getModifiers(); if ($isAbstractMethod | $isInterfaceMethod) { $visibility = $visibility | Constants::ABSTRACT_ONLY; } return $visibility; }