Example #1
0
 /**
  * @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);
 }
Example #2
0
 /**
  *  Dispatch the request, return the response
  *
  *  @return Response The returned response
  */
 public function dispatch()
 {
     $service = $this->request->getService();
     $method = $this->request->getMethod();
     $params = (array) $this->request->getParams();
     try {
         $handlerClass = sprintf('Handler_%s', ucfirst($service));
         $handler = new $handlerClass($this->request);
     } catch (Exception $e) {
         $this->jsonError(JSONRPC_ERROR_METHOD_NOT_FOUND, 'Requested service unknown');
     }
     if (!method_exists($handler, $method)) {
         $this->jsonError(JSONRPC_ERROR_METHOD_NOT_FOUND, 'Requested method unknown');
     }
     $ref = new ReflectionMethod($handler, $method);
     $handlerParams = $ref->getParameters();
     foreach ($handlerParams as $handlerParam) {
         if (!array_key_exists($handlerParam->name, $params)) {
             $this->jsonError(JSONRPC_ERROR_INVALID_PARAMS, sprintf('Missing parameter "%s"', $handlerParam->name));
         }
     }
     if (count($params) !== $ref->getNumberOfRequiredParameters()) {
         $this->jsonError(JSONRPC_ERROR_INVALID_PARAMS, 'Wrong number of parameters');
     }
     Context::getInstance()->getLogger()->info(sprintf('Executing method "%s" in service "%s" with parameters "%s"', $method, $handlerClass, json_encode($params)));
     return call_user_func_array(array($handler, $method), $params);
 }
Example #3
0
 static function executeControllerAction($controller, $action, $args)
 {
     if (self::controllerExists($controller)) {
         if (!method_exists($controller, $action)) {
             if (method_exists($controller, self::$method_unknown)) {
                 array_unshift($args, $action);
                 $action = self::$method_unknown;
             } else {
                 throw new ErrorNotFound("Method " . $action . " could not be found in Controller " . $controller);
             }
         }
     } else {
         //fallback to unkown controller method in main
         if (self::controllerExists("main") && method_exists("main", self::$method_unknown)) {
             array_unshift($args, $controller, $action);
             $controller = "main";
             $action = self::$method_unknown;
         } else {
             throw new ErrorNotFound("Controller " . $controller . " can not be loaded.");
         }
     }
     #check for parameter-count
     $method = new ReflectionMethod($controller, $action);
     $parametercount = $method->getNumberOfRequiredParameters();
     if (count($args) < $parametercount) {
         throw new ErrorNotAllowed("Can't call " . $controller . "." . $action . ".\n" . "Got " . count($args) . " arguments but at least " . $parametercount . " are required.");
     }
     #call it
     $instance = new $controller($controller);
     call_user_func_array(array($instance, $action), $args);
 }
Example #4
0
 /**
  * @param \ReflectionMethod $method
  * @return bool
  */
 private function isAutoloadMethod(\ReflectionMethod $method)
 {
     if (strpos($method->getName(), KnotConsts::AUTOLOAD_METHOD_PREFIX) !== 0 || $method->getNumberOfParameters() != 1 || $method->getNumberOfRequiredParameters() != 1 || $method->isStatic() || $method->isAbstract() || !Extractor::instance()->has($method, KnotConsts::AUTOLOAD_ANNOTATIONS)) {
         return false;
     }
     return true;
 }
Example #5
0
 /**
  * Método para verificar se os parâmetros informados são pelo menos o total
  * exigido na classe do módulo.
  * Adicionada a chamada __call() caso a classe tenha
  *
  * @throws ControleException
  */
 private static function checarParametros()
 {
     // Se o total de parâmetros não suprir o número requerido
     if (self::$metodo->getName() != '__call' && count(self::$dadosUrl) < self::$metodo->getNumberOfRequiredParameters()) {
         throw new ControleException(ControleException::PARAMETROS_INSUFICIENTES, ucfirst(self::$modulo) . "::" . self::$acao);
     }
 }
 /**
  * Return Transport. example: TransportFactory::GetTransport('SSH', $ssh_host, $ssh_port, $ssh_user, $ssh_pass);
  *
  * @static 
  * @param string $transportname
  * @return Object
  */
 public static function GetTransport($transportname)
 {
     $path_to_transports = dirname(__FILE__) . "/Transports";
     if (file_exists("{$path_to_transports}/class.{$transportname}Transport.php")) {
         Core::Load("class.{$transportname}Transport.php", $path_to_transports);
         if (class_exists("{$transportname}Transport") && self::IsTransport("{$transportname}Transport")) {
             // Get Constructor Reflection
             if (is_callable(array("{$transportname}Transport", "__construct"))) {
                 $reflect = new ReflectionMethod("{$transportname}Transport", "__construct");
             }
             // Delete $objectname from arguments
             $num_args = func_num_args() - 1;
             $args = func_get_args();
             array_shift($args);
             if ($reflect) {
                 $required_params = $reflect->getNumberOfRequiredParameters();
                 if ($required_params > $num_args) {
                     $params = $reflect->getParameters();
                     //TODO: Show what params are missing in error
                     Core::RaiseError(sprintf(_("Missing some required arguments for %s Transport constructor. Passed: %s, expected: %s."), $transportname, $num_args, $required_params));
                 }
             }
             $reflect = new ReflectionClass("{$transportname}Transport");
             if (count($args) > 0) {
                 return $reflect->newInstanceArgs($args);
             } else {
                 return $reflect->newInstance(true);
             }
         } else {
             Core::RaiseError(sprintf(_("Class '%s' not found or doesn't implements ITransport interface"), "{$transportname}Transport"));
         }
     }
 }
Example #7
0
 public function execute($argv)
 {
     if (!is_array($argv)) {
         $argv = array($argv);
     }
     $argc = count($argv);
     if (empty($this->action)) {
         throw new \Jolt\Exception('controller_action_not_set');
     }
     try {
         $action = new \ReflectionMethod($this, $this->action);
     } catch (\ReflectionException $e) {
         throw new \Jolt\Exception('controller_action_not_part_of_class');
     }
     $paramCount = $action->getNumberOfRequiredParameters();
     if ($paramCount != $argc && $paramCount > $argc) {
         $argv = array_pad($argv, $paramCount, NULL);
     }
     ob_start();
     if ($action->isPublic()) {
         if ($action->isStatic()) {
             $action->invokeArgs(NULL, $argv);
         } else {
             $action->invokeArgs($this, $argv);
         }
     }
     $renderedController = ob_get_clean();
     if (!empty($renderedController)) {
         $this->renderedController = $renderedController;
     } else {
         $this->renderedController = $this->renderedView;
     }
     return $this->renderedController;
 }
Example #8
0
 public function invokeMethod($method, $params)
 {
     // for named parameters, convert from object to assoc array
     if (is_object($params)) {
         $array = array();
         foreach ($params as $key => $val) {
             $array[$key] = $val;
         }
         $params = array($array);
     }
     // for no params, pass in empty array
     if ($params === null) {
         $params = array();
     }
     $reflection = new \ReflectionMethod($this->exposed_instance, $method);
     // only allow calls to public functions
     if (!$reflection->isPublic()) {
         throw new Serverside\Exception("Called method is not publically accessible.");
     }
     // enforce correct number of arguments
     $num_required_params = $reflection->getNumberOfRequiredParameters();
     if ($num_required_params > count($params)) {
         throw new Serverside\Exception("Too few parameters passed.");
     }
     return $reflection->invokeArgs($this->exposed_instance, $params);
 }
 private function getControllerObject(\ReflectionClass $rc, \ReflectionMethod $ra, array $params)
 {
     if ($ra->getNumberOfRequiredParameters() > count($params)) {
         throw new NotFoundException("Wrong number of parameters.");
     }
     return $rc->newInstance($this);
 }
Example #10
0
 public function callQueueMethod(Queue $queue, $method)
 {
     $r = new \ReflectionMethod($queue, $method);
     if ($num = $r->getNumberOfRequiredParameters()) {
         return call_user_func_array([$queue, $method], array_fill(0, $num, 'foo'));
     }
     return $queue->{$method}();
 }
Example #11
0
 /**
  * Returns the number of required parameters
  *
  * @return integer The number of required parameters
  * @since PHP 5.0.3
  */
 public function getNumberOfRequiredParameters()
 {
     if ($this->reflectionSource instanceof ReflectionMethod) {
         return $this->reflectionSource->getNumberOfRequiredParameters();
     } else {
         return parent::getNumberOfRequiredParameters();
     }
 }
Example #12
0
 public function __construct(\ReflectionMethod $reflector)
 {
     $this->name = $reflector->name;
     $this->class = $reflector->class;
     $this->export = preg_match('/@Export\\s/', $reflector->getDocComment()) > 0;
     $this->reqParamCount = $reflector->getNumberOfRequiredParameters();
     $this->isPublic = $reflector->isPublic();
     $this->isStatic = $reflector->isStatic();
 }
Example #13
0
 public function testExecute_ParamCount()
 {
     $action = 'paramAction';
     $controller = new Index();
     $controller->setAction($action);
     $reflectionAction = new \ReflectionMethod($controller, $action);
     $expectedParamCount = $reflectionAction->getNumberOfRequiredParameters();
     $actualParamCount = $controller->execute(array(10));
     $this->assertEquals($expectedParamCount, $actualParamCount);
 }
Example #14
0
 function resolve2($context, array $path)
 {
     $original_path = $path;
     $head = array_shift($path);
     $args = $path;
     $head = $this->translate($head);
     // If the head is empty, then the URL ended in a slash (/), assume
     // the index is implied
     if (!$head) {
         $head = 'index';
     }
     try {
         $method = new \ReflectionMethod($context, $head);
         // Ensure that the method is visible
         if (!$method->isPublic()) {
             return false;
         }
         // Check if argument count matches the rest of the URL
         if (count($args) < $method->getNumberOfRequiredParameters()) {
             // Not enough parameters in the URL
             return false;
         }
         if (count($args) > ($C = $method->getNumberOfParameters())) {
             // Too many parameters in the URL — pass as many as possible to the function
             $path = array_slice($args, $C);
             $args = array_slice($args, 0, $C);
         }
         // Try to call the method and see what kind of response we get
         $result = $method->invokeArgs($context, $args);
         if ($result instanceof View\BaseView) {
             return $result;
         } elseif (is_callable($result)) {
             // We have a callable to be considered the view. We're done.
             return new View\BoundView($result, $args);
         } elseif ($result instanceof Dispatcher) {
             // Delegate to a sub dispatcher
             return $result->resolve(implode('/', $path));
         } elseif (is_object($result)) {
             // Recurse forward with the remainder of the path
             return $this->resolve2($result, $path);
         }
         // From here, we assume that the call failed
     } catch (\ReflectionException $ex) {
         // No such method, try def() or recurse backwards
     } catch (Exception\ConditionFailed $ex) {
         // The matched method refused the request — recurse backwards
     }
     // Not able to dispatch the method. Try def()
     if ($head != 'def') {
         $path = array_merge(['def'], $original_path);
         return $this->resolve2($context, $path);
     }
     // Unable to dispatch the request
     return false;
 }
Example #15
0
 /**
  * "Start" the application:
  * Analyze the URL elements and calls the according controller/method or the fallback
  */
 public function __construct()
 {
     // create array with URL parts in $url
     $this->splitUrl();
     // check for controller: no controller given ? then load start-page
     if (!$this->controllerName) {
         require CONTROLLER_PATH . 'home_ctrl.php';
         $page = new HomeCtrl();
         $page->index();
     } elseif ($this->controllerName == 'public') {
         return;
     } elseif (!file_exists(CONTROLLER_PATH . $this->controllerName . '_ctrl.php')) {
         require CONTROLLER_PATH . 'error_ctrl.php';
         $page = new ErrorCtrl();
         $page->notFound();
     } else {
         // here we did check for controller: does such a controller exist ?
         // if so, then load this file and create this controller
         // example: if controller would be "car", then this line would translate into: $this->car = new car();
         $controllerFile = $this->controllerName . '_ctrl.php';
         $controllerName = $this->controllerName . 'Ctrl';
         require CONTROLLER_PATH . $controllerFile;
         $this->controller = new $controllerName();
         // check for method: does such a method exist in the controller ?
         if (!method_exists($this->controller, $this->actionName)) {
             if (strlen($this->actionName) == 0) {
                 // no action defined: call the default index() method of a selected controller
                 $this->controller->index();
             } else {
                 require CONTROLLER_PATH . 'error_ctrl.php';
                 $page = new ErrorCtrl();
                 $page->notFound();
             }
         } else {
             $reflectionMethod = new \ReflectionMethod($this->controller, $this->actionName);
             $numberOfRequiredParameters = $reflectionMethod->getNumberOfRequiredParameters();
             if (sizeof($this->params) < $numberOfRequiredParameters) {
                 require CONTROLLER_PATH . 'error_ctrl.php';
                 $page = new ErrorCtrl();
                 $page->notFound();
             } else {
                 if (!empty($this->params)) {
                     // Call the method and pass arguments to it
                     call_user_func_array(array($this->controller, $this->actionName), $this->params);
                 } else {
                     // If no parameters are given, just call the method without parameters, like $this->home->method();
                     $this->controller->{$this->actionName}();
                 }
             }
         }
     }
 }
Example #16
0
 /**
  * Runs the test method.
  * @return void
  */
 private function runMethod($method)
 {
     $method = new \ReflectionMethod($this, $method);
     if (!$method->isPublic()) {
         throw new TestCaseException("Method {$method->getName()} is not public. Make it public or rename it.");
     }
     $data = array();
     $info = Helpers::parseDocComment($method->getDocComment()) + array('dataprovider' => NULL, 'throws' => NULL);
     if ($info['throws'] === '') {
         throw new TestCaseException("Missing class name in @throws annotation for {$method->getName()}().");
     } elseif (is_array($info['throws'])) {
         throw new TestCaseException("Annotation @throws for {$method->getName()}() can be specified only once.");
     } else {
         $throws = preg_split('#\\s+#', $info['throws'], 2) + array(NULL, NULL);
     }
     $defaultParams = array();
     foreach ($method->getParameters() as $param) {
         $defaultParams[$param->getName()] = $param->isDefaultValueAvailable() ? $param->getDefaultValue() : NULL;
     }
     foreach ((array) $info['dataprovider'] as $provider) {
         $res = $this->getData($provider);
         if (!is_array($res)) {
             throw new TestCaseException("Data provider {$provider}() doesn't return array.");
         }
         foreach ($res as $set) {
             $data[] = is_string(key($set)) ? array_merge($defaultParams, $set) : $set;
         }
     }
     if (!$info['dataprovider']) {
         if ($method->getNumberOfRequiredParameters()) {
             throw new TestCaseException("Method {$method->getName()}() has arguments, but @dataProvider is missing.");
         }
         $data[] = array();
     }
     foreach ($data as $args) {
         try {
             if ($info['throws']) {
                 $tmp = $this;
                 $e = Assert::error(function () use($tmp, $method, $args) {
                     $tmp->runTest($method->getName(), $args);
                 }, $throws[0], $throws[1]);
                 if ($e instanceof AssertException) {
                     throw $e;
                 }
             } else {
                 $this->runTest($method->getName(), $args);
             }
         } catch (AssertException $e) {
             throw $e->setMessage("{$e->origMessage} in {$method->getName()}" . substr(Dumper::toLine($args), 5));
         }
     }
 }
Example #17
0
 private static function validateCall()
 {
     $controller = 'application\\controllers\\' . ucfirst(self::$request->controller);
     $reflection = new \ReflectionMethod($controller, ucfirst(self::$request->action));
     $countWaitingParams = $reflection->getNumberOfParameters();
     $countWaitingRequiredParams = $reflection->getNumberOfRequiredParameters();
     $countComingParams = count(self::$request->params);
     if ($countComingParams > $countWaitingParams || $countComingParams < $countWaitingRequiredParams) {
         throw new InvalidException("Passed wrong number of arguments to the method", 404);
     } else {
         return $controller;
     }
 }
Example #18
0
 /**
  * Overload all calls to the adapter and redir them to the @Object contained.
  * __callStatic() only in PHP >= 5.3.0
  * @param  $method
  * @param  $parameters
  * @return
  */
 public function __call($method, $parameters)
 {
     try {
         $method = new ReflectionMethod($this->modelObject, $method);
         if ($method->getNumberOfRequiredParameters() > 0) {
             return $method->invokeArgs($this->modelObject, $parameters);
         } else {
             return $method->invoke($this->modelObject, null);
         }
     } catch (ReflectionException $e) {
         Soprano::exception($e->getMessage());
     }
 }
Example #19
0
File: Router.php Project: h1soft/h
 public function dispatch()
 {
     $this->initRequest();
     if (!$this->cInstance) {
         $this->_notfound();
     }
     $this->cInstance->init();
     $this->cInstance->before();
     if ($this->cInstance instanceof Controller && method_exists($this->cInstance, $this->getActionName())) {
         $reflectionMethod = new \ReflectionMethod($this->cInstance, $this->getActionName());
         if ($reflectionMethod->getNumberOfRequiredParameters() > 0) {
             $paramsWithid = $this->application->request()->getParamArrays();
             $paramsWithName = $this->application->request()->getParams();
             $ps = array();
             foreach ($reflectionMethod->getParameters() as $i => $param) {
                 $name = $param->getName();
                 if (isset($paramsWithName[$name])) {
                     if ($param->isArray()) {
                         $ps[] = is_array($paramsWithName[$name]) ? $paramsWithName[$name] : array($paramsWithName[$name]);
                     } else {
                         if (!is_array($paramsWithName[$name])) {
                             $ps[] = $paramsWithName[$name];
                         }
                     }
                 } else {
                     if (isset($paramsWithid[$i])) {
                         $ps[] = $paramsWithid[$i];
                     } else {
                         if ($param->isDefaultValueAvailable()) {
                             $ps[] = $param->getDefaultValue();
                         } else {
                             $ps[] = NULL;
                         }
                     }
                 }
             }
             $reflectionMethod->invokeArgs($this->cInstance, $ps);
             //                call_user_func_array(array($this->cInstance,  $this->getActionName()), array());
         } else {
             $reflectionMethod->invoke($this->cInstance);
         }
     } else {
         if ($this->cInstance instanceof RestController) {
             call_user_func_array(array($this->cInstance, 'dispatch'), array($this->getActionName(), $this->application->request()->getParamArrays()));
             //            call_user_func_array(array($this->cInstance, $this->getActionName()), $this->application->request()->getParamArrays());
         } else {
             $this->_notfound();
         }
     }
     $this->cInstance->after();
 }
 /**
  * Realiza el dispatch de una ruta
  *
  * @return Object
  */
 public static function execute($route)
 {
     extract($route, EXTR_OVERWRITE);
     if (!(include_once APP_PATH . "controllers/{$controller_path}" . '_controller.php')) {
         throw new KumbiaException(NULL, 'no_controller');
     }
     //Asigna el controlador activo
     $app_controller = Util::camelcase($controller) . 'Controller';
     $cont = self::$_controller = new $app_controller($module, $controller, $action, $parameters);
     View::select($action);
     View::setPath($controller_path);
     // Se ejecutan los filtros before
     if ($cont->k_callback('initialize') === FALSE) {
         return $cont;
     }
     if ($cont->k_callback('before_filter') === FALSE) {
         return $cont;
     }
     //Se ejecuta el metodo con el nombre de la accion
     //en la clase de acuerdo al convenio
     if (!method_exists($cont, $action)) {
         throw new KumbiaException(NULL, 'no_action');
     }
     //Obteniendo el metodo
     $reflectionMethod = new ReflectionMethod($cont, $action);
     //k_callback y __constructor metodo reservado
     if ($reflectionMethod->name == 'k_callback' || $reflectionMethod->isConstructor()) {
         throw new KumbiaException('Esta intentando ejecutar un método reservado de KumbiaPHP');
     }
     //se verifica que el metodo sea public
     if (!$reflectionMethod->isPublic()) {
         throw new KumbiaException(NULL, 'no_action');
     }
     //se verifica que los parametros que recibe
     //la action sea la cantidad correcta
     $num_params = count($parameters);
     if ($cont->limit_params && ($num_params < $reflectionMethod->getNumberOfRequiredParameters() || $num_params > $reflectionMethod->getNumberOfParameters())) {
         throw new KumbiaException("Número de parámetros erroneo para ejecutar la acción \"{$action}\" en el controlador \"{$controller}\"");
     }
     $reflectionMethod->invokeArgs($cont, $parameters);
     //Corre los filtros after
     $cont->k_callback('after_filter');
     $cont->k_callback('finalize');
     //Si esta routed volver a ejecutar
     if (Router::getRouted()) {
         Router::setRouted(FALSE);
         return Dispatcher::execute(Router::get());
         // Vuelve a ejecutar el dispatcher
     }
     return $cont;
 }
Example #21
0
 /**
  * @param string $context
  * @param string $controller
  * @param string $action
  * @param array|string|null $params
  * @return string $controller
  * @throws \Exception
  */
 private static function validateCall($context, $controller, $action, $params = null)
 {
     $controller = 'App\\' . ucfirst($context) . '\\Controller\\' . ucfirst($controller) . "Controller";
     $action = 'action' . ucfirst($action);
     $rFunction = new \ReflectionMethod($controller, $action);
     $countParams = $rFunction->getNumberOfParameters();
     $countRequiredParams = $rFunction->getNumberOfRequiredParameters();
     $countArgs = count($params);
     if ($countArgs > $countParams || $countArgs < $countRequiredParams) {
         throw new HttpException("Passed wrong number of arguments to the method", 404);
     } else {
         return $controller;
     }
 }
Example #22
0
 public static function a2o(&$_object, $_data)
 {
     if (is_array($_data)) {
         foreach ($_data as $key => $value) {
             $method = 'set' . ucfirst($key);
             if (method_exists($_object, $method)) {
                 $function = new ReflectionMethod($_object, $method);
                 if (is_json($value)) {
                     $value = json_decode($value, true);
                 }
                 if (is_array($value)) {
                     if ($function->getNumberOfRequiredParameters() == 2) {
                         foreach ($value as $arrayKey => $arrayValue) {
                             if (is_array($arrayValue)) {
                                 if ($function->getNumberOfRequiredParameters() == 3) {
                                     foreach ($arrayValue as $arrayArraykey => $arrayArrayvalue) {
                                         $_object->{$method}($arrayKey, $arrayArraykey, $arrayArrayvalue);
                                     }
                                 } else {
                                     $_object->{$method}($arrayKey, $arrayValue);
                                 }
                             } else {
                                 $_object->{$method}($arrayKey, $arrayValue);
                             }
                         }
                     } else {
                         $_object->{$method}(json_encode($value, JSON_UNESCAPED_UNICODE));
                     }
                 } else {
                     if ($function->getNumberOfRequiredParameters() < 2) {
                         $_object->{$method}($value);
                     }
                 }
             }
         }
     }
 }
Example #23
0
 /**
  * Create path for URI from method parameter list
  * 
  * @param \ReflectionMethod $method
  * @return string
  */
 protected static function getPathPartDefinedByParameters(\ReflectionMethod $method)
 {
     $path = '';
     $pathEnd = '';
     $reqPar = $method->getNumberOfRequiredParameters();
     foreach ($method->getParameters() as $key => $param) {
         if ($key < $reqPar) {
             $path .= '/{' . preg_replace('#_$#', '+', $param->name) . '}';
         } else {
             $path .= '[/{' . $param->name . '}';
             $pathEnd .= ']';
         }
     }
     return $path . $pathEnd;
 }
 public function __set($name, $value)
 {
     $method = 'set_' . $name;
     if (method_exists($this, $method)) {
         return call_user_func(array($this, $method), $value);
     }
     $set_method_name = 'set_' . $method;
     if (method_exists($this, $set_method_name)) {
         $set_method = new \ReflectionMethod(get_class($this), $set_method_name);
         if ($set_method->getNumberOfRequiredParameters() <= 1) {
             return call_user_func_array(array($this, $set_method_name), array($value));
         }
     }
     return parent::__set($name, $value);
     //			return $this->set_param($name, $value);
 }
Example #25
0
 protected function setAction($action, $params)
 {
     try {
         $reflector = new ReflectionMethod($this->controller, $action);
         if (!$reflector->isPublic()) {
             throw new Exception();
         }
         if (count($params) < $reflector->getNumberOfRequiredParameters()) {
             $this->error(400, 'Method is missing required parameters');
         }
     } catch (Exception $e) {
         $this->error(404, 'Unknown method');
     }
     $this->action = $action;
     $this->params = $params;
 }
Example #26
0
 public static function createFromToken(FunctionDefine $aFunctionDefine)
 {
     if (!($aClassDefine = $aFunctionDefine->belongsClass())) {
         throw new Exception("传入的 \$aFunctionDefine 参数无效,必须是一个类方法的定义Token");
     }
     try {
         $aMethodRef = new \ReflectionMethod($aClassDefine->fullName(), $aFunctionDefine->name());
     } catch (\Exception $e) {
         throw new Exception("无法找到 Pointcut %s::%s 的定义", array($aClassDefine->fullName(), $aFunctionDefine->name()), $e);
     }
     // 检查参数(不能有非可缺省的参数)
     if ($aMethodRef->getNumberOfRequiredParameters()) {
         throw new Exception("Pointcut %s::%s() 的定义无效:要求了非可缺省的参数; 请检查该Pointcut的参数表。", array($aClassDefine->fullName(), $aFunctionDefine->name()));
     }
     // 声明为静态方法
     if ($aMethodRef->isStatic()) {
         if (!$aMethodRef->isPublic()) {
             throw new Exception("Pointcut %s::%s() 声明为 static 类型,static 类型的 Pointcut 必须为 public。", array($aClassDefine->fullName(), $aFunctionDefine->name()));
         }
         $arrJointPoints = call_user_func(array($aClassDefine->fullName(), $aFunctionDefine->name()));
     } else {
         try {
             $aClassRef = new \ReflectionClass($aClassDefine->fullName());
         } catch (\Exception $e) {
             throw new Exception("无法找到 Aspect %s 的定义,无法定义Pointcut:%s::%s", array($aClassDefine->fullName(), $aClassDefine->fullName(), $aFunctionDefine->name()), $e);
         }
         // 检查该类的构造函数的参数
         if ($aConstructor = $aClassRef->getConstructor() and $aConstructor->getNumberOfRequiredParameters()) {
             throw new Exception("由于 Pointcut %s::%s() 没有被申明为 static ,则所属的Aspect(%s)的构造函数不能要求非可省的参数。将 Pointcut %s::%s() 声明为 static,或者取消Aspect(%s)的构造函数所要求的非可省参数。", array($aClassDefine->fullName(), $aFunctionDefine->name(), $aClassDefine->fullName(), $aClassDefine->fullName(), $aFunctionDefine->name(), $aClassDefine->fullName()));
         }
         $aMethodRef->setAccessible(true);
         $arrJointPoints = $aMethodRef->invokeArgs($aClassRef->newInstanceArgs(), array());
     }
     $aPointcut = new self($aFunctionDefine->name());
     $aPointcut->sDefineMethod = $aFunctionDefine->name();
     if (is_array($arrJointPoints)) {
         foreach ($arrJointPoints as $aJointPoint) {
             if ($aJointPoint instanceof JointPoint) {
                 $aPointcut->jointPoints()->add($aJointPoint);
                 $aJointPoint->setPointcut($aPointcut);
             } else {
                 throw new Exception("Pointcut %s::%s 的定义中,申明了无效的 JointPoint: %s", array($aClassDefine->fullName(), $aFunctionDefine->name(), var_export($aJointPoint, true)));
             }
         }
     }
     return $aPointcut;
 }
Example #27
0
 protected function setUp()
 {
     // Set rule method
     $this->ruleMethod = 'rule_' . substr($this->getName(), strlen('test_'));
     try {
         $ruleMethod = new ReflectionMethod('vacuum\\Rules', $this->ruleMethod);
         $this->assertTrue($ruleMethod->isStatic(), 'Check if method is static');
         $this->assertTrue($ruleMethod->isPublic(), 'Check if method is public');
         $this->assertContains($ruleMethod->getNumberOfRequiredParameters(), [0, 1, 2], 'Check if method has 1 or 2 arguments');
         $params = $ruleMethod->getParameters();
         foreach ($params as $param) {
             $this->assertFalse($param->isPassedByReference(), 'Check if there are no arguments setted via reference');
         }
     } catch (ReflectionException $e) {
         $this->assertTrue(false, 'Check if validation method exists');
     }
 }
 /**
  * Ensure that this callback takes no arguments
  *
  * @param callable $cb
  */
 public static function validateCallback(callable $cb)
 {
     if (is_string($cb) and strpos($cb, "::") !== false) {
         $cb = explode("::", $cb);
     }
     if (is_string($cb) or $cb instanceof \Closure) {
         $function = new \ReflectionFunction($cb);
         if ($function->getNumberOfRequiredParameters() > 0) {
             throw new \InvalidArgumentException("Callable requires parameters");
         }
     } elseif (is_array($cb)) {
         list($ctx, $m) = $cb;
         $method = new \ReflectionMethod($ctx, $m);
         if ($method->getNumberOfRequiredParameters() > 0) {
             throw new \InvalidArgumentException("Callable requires parameters");
         }
     }
 }
Example #29
0
 protected function valid_method($method, $passedParams)
 {
     if (method_exists($this, $method)) {
         $reflectionMethod = new ReflectionMethod($this, $method);
         if (!$reflectionMethod->isPublic()) {
             $error = "The method must be public";
         }
         if (count($passedParams) < $reflectionMethod->getNumberOfRequiredParameters()) {
             $error = 'The method must be called with the number or required parameters';
         }
     } else {
         $error = 'The method "' . $method . '" does not exist';
     }
     if (isset($error)) {
         show_error($error);
         exit;
     }
 }
 /**
  * Attempt to publish the object, if it supports this funcitonality.
  */
 public static function attempt_publish($obj)
 {
     if ($obj->hasExtension('Versioned')) {
         if (method_exists($obj, 'doPublish')) {
             // Detect legacy function signatures with parameters (e.g. as in EditableFormFields)
             $reflection = new ReflectionMethod(get_class($obj), 'doPublish');
             if ($reflection->getNumberOfRequiredParameters() == 0) {
                 // New
                 $obj->doPublish();
             } else {
                 // Legacy
                 $obj->doPublish('Stage', 'Live');
             }
         } else {
             // Versioned default
             $obj->publish('Stage', 'Live');
         }
     }
 }