PHP Zend_Reflection_Class::getMethods方法代码示例

 /**
  * fromReflection() - build a Code Generation PHP Object from a Class Reflection
  *
  * @param Zend_Reflection_Class $reflectionClass
  * @return dmZendCodeGeneratorPhpClass
  */
 public static function fromReflection(Zend_Reflection_Class $reflectionClass)
 {
     $class = new self();
     $class->setSourceContent($class->getSourceContent());
     $class->setSourceDirty(false);
     if ($reflectionClass->getDocComment() != '') {
         $class->setDocblock(Zend_CodeGenerator_Php_Docblock::fromReflection($reflectionClass->getDocblock()));
     }
     $class->setAbstract($reflectionClass->isAbstract());
     $class->setName($reflectionClass->getName());
     if ($parentClass = $reflectionClass->getParentClass()) {
         $class->setExtendedClass($parentClass->getName());
         $interfaces = array_diff($parentClass->getInterfaces(), $reflectionClass->getInterfaces());
     } else {
         $interfaces = $reflectionClass->getInterfaces();
     }
     $class->setImplementedInterfaces($interfaces);
     $properties = array();
     foreach ($reflectionClass->getProperties() as $reflectionProperty) {
         if ($reflectionProperty->getDeclaringClass()->getName() == $class->getName()) {
             $properties[] = Zend_CodeGenerator_Php_Property::fromReflection($reflectionProperty);
         }
     }
     $class->setProperties($properties);
     $methods = array();
     foreach ($reflectionClass->getMethods(-1, 'dmZendReflectionMethod') as $reflectionMethod) {
         if ($reflectionMethod->getDeclaringClass()->getName() == $class->getName()) {
             $methods[] = dmZendCodeGeneratorPhpMethod::fromReflection($reflectionMethod);
         }
     }
     $class->setMethods($methods);
     return $class;
 }

 public function testMethodReturns()
 {
     $reflectionClass = new Zend_Reflection_Class('Zend_Reflection_TestSampleClass2');
     $methodByName = $reflectionClass->getMethod('getProp1');
     $this->assertEquals('Zend_Reflection_Method', get_class($methodByName));
     $methodsAll = $reflectionClass->getMethods();
     $this->assertEquals(3, count($methodsAll));
     $firstMethod = array_shift($methodsAll);
     $this->assertEquals('getProp1', $firstMethod->getName());
 }

 /**
  * _processActionableMethods() - process all methods that can be called on this provider.
  *
  */
 protected function _processActionableMethods()
 {
     $specialtyRegex = '#(.*)(' . implode('|', $this->_specialties) . ')$#i';
     $methods = $this->_providerReflection->getMethods();
     $actionableMethods = array();
     foreach ($methods as $method) {
         $methodName = $method->getName();
         /**
          * the following will determine what methods are actually actionable
          * public, non-static, non-underscore prefixed, classes that dont
          * contain the name "
          */
         if (!$method->getDeclaringClass()->isInstantiable() || !$method->isPublic() || $methodName[0] == '_' || $method->isStatic() || in_array($methodName, array('getContextClasses', 'getName'))) {
             continue;
         }
         /**
          * check to see if the method was a required method by a Zend_Tool_* interface
          */
         foreach ($method->getDeclaringClass()->getInterfaces() as $methodDeclaringClassInterface) {
             if (strpos($methodDeclaringClassInterface->getName(), 'Zend_Tool_') === 0 && $methodDeclaringClassInterface->hasMethod($methodName)) {
                 continue 2;
             }
         }
         $actionableName = ucfirst($methodName);
         if (substr($actionableName, -6) == 'Action') {
             $actionableName = substr($actionableName, 0, -6);
         }
         $actionableMethods[$methodName]['methodName'] = $methodName;
         $matches = null;
         if (preg_match($specialtyRegex, $actionableName, $matches)) {
             $actionableMethods[$methodName]['actionName'] = $matches[1];
             $actionableMethods[$methodName]['specialty'] = $matches[2];
         } else {
             $actionableMethods[$methodName]['actionName'] = $actionableName;
             $actionableMethods[$methodName]['specialty'] = '_Global';
         }
         // get the action, and create non-existent actions when they dont exist (the true part below)
         $action = $this->_registry->getActionRepository()->getAction($actionableMethods[$methodName]['actionName']);
         if ($action == null) {
             $action = new Zend_Tool_Framework_Action_Base($actionableMethods[$methodName]['actionName']);
             $this->_registry->getActionRepository()->addAction($action);
         }
         $actionableMethods[$methodName]['action'] = $action;
         if (!in_array($actionableMethods[$methodName]['action'], $this->_actions)) {
             $this->_actions[] = $actionableMethods[$methodName]['action'];
         }
         $parameterInfo = array();
         $position = 1;
         foreach ($method->getParameters() as $parameter) {
             $currentParam = $parameter->getName();
             $parameterInfo[$currentParam]['position'] = $position++;
             $parameterInfo[$currentParam]['optional'] = $parameter->isOptional();
             $parameterInfo[$currentParam]['default'] = $parameter->isOptional() ? $parameter->getDefaultValue() : null;
             $parameterInfo[$currentParam]['name'] = $currentParam;
             $parameterInfo[$currentParam]['type'] = 'string';
             $parameterInfo[$currentParam]['description'] = null;
         }
         $matches = null;
         if (($docComment = $method->getDocComment()) != '' && preg_match_all('/@param\\s+(\\w+)+\\s+(\\$\\S+)\\s+(.*?)(?=(?:\\*\\s*@)|(?:\\*\\/))/s', $docComment, $matches)) {
             for ($i = 0; $i <= count($matches[0]) - 1; $i++) {
                 $currentParam = ltrim($matches[2][$i], '$');
                 if ($currentParam != '' && isset($parameterInfo[$currentParam])) {
                     $parameterInfo[$currentParam]['type'] = $matches[1][$i];
                     $descriptionSource = $matches[3][$i];
                     if ($descriptionSource != '') {
                         $parameterInfo[$currentParam]['description'] = trim($descriptionSource);
                     }
                 }
             }
         }
         $actionableMethods[$methodName]['parameterInfo'] = $parameterInfo;
     }
     $this->_actionableMethods = $actionableMethods;
 }

 /**
  * Get all defined actions for a module/controller combination from the sources
  *
  * Scan the Controller in a module for actions.
  * The scanning is pure on the source and the nameing convention, which means
  * only methods in the controller that fit the format
  *          [name]Action
  * will be used as action
  *
  * For a little bit more comfort, the DocString will be used as description
  * of the Action.
  *
  * Returning result is an array of Admin_Model_DbRow_Action elements
  *
  * @return array
  */
 public function getActions($modul, $controller)
 {
     $actions = array();
     $className = ucfirst($modul) . '_Model_Modules_' . ucfirst($controller);
     $classFile = ucfirst($controller) . '.php';
     if (file_exists($this->path . $classFile)) {
         // load the file
         require_once $this->path . $classFile;
         $reflect = new Zend_Reflection_Class($className);
         foreach ($reflect->getMethods() as $method) {
             if (preg_match('/(\\w+)Action$/', $method->getName(), $match)) {
                 $actionComment = $method->getName();
                 $name = $match[1];
                 $docComment = $method->getDocComment();
                 if (is_string($docComment)) {
                     $commentRows = explode("\n", $docComment);
                     $actionComment = preg_replace("/^\\s*\\*\\s*(.*)\\s*/", '$1', $commentRows[1]);
                     if ($actionComment === "") {
                         $actionComment = $docComment;
                     }
                 }
                 $actions[] = new Admin_Model_DbRow_Action(array('actionName' => $name, 'description' => $actionComment));
             }
         }
     }
     return $actions;
 }

<?php

$tt = array('' => '[ не указан ]');
$data = Zkernel_Common::getControllerDocblock();
if ($data) {
    foreach ($data as $n => $db) {
        $nn = $n;
        $c = ucfirst($n) . 'Controller';
        if (isset($db['zk_title'])) {
            $nn = $db['zk_title'];
        }
        $inner = array();
        $r = new Zend_Reflection_Class($c);
        $met = $r->getMethods();
        if (@$met) {
            $exist = false;
            foreach ($met as $el) {
                if ($el->name == '_getRoutes') {
                    $rq = new Zend_Controller_Request_Http();
                    $rq->setControllerName($n);
                    $ci = new $c($rq, new Zend_Controller_Response_Http());
                    $ci->init();
                    $rs = $ci->_getRoutes();
                    if ($rs) {
                        foreach ($rs as $k_1 => $el_1) {
                            $is_route = strpos($k_1, '|');
                            $ap = 'index';
                            $pp = explode('@', $k_1);
                            if (count($pp) == 2) {
                                $ap = $pp[0];
                                $k_1 = $pp[1];

 /**
  * Get all Actions for a modul / controller
  *
  * Method scans modul/controller for actions, which have the Zend Framework
  * action method namespacing, like "indexAction".
  *
  * @param string $modul
  * @param string $controller
  * @return array
  * @access public
  */
 public function getActions($modul, $controller, $virtual)
 {
     $actions = array();
     if ($virtual == 0) {
         $frontController = Zend_Controller_Front::getInstance();
         $className = ucfirst($modul) . '_' . ucfirst($controller) . 'Controller';
         $classFile = ucfirst($controller) . 'Controller.php';
         $directory = $frontController->getControllerDirectory($modul);
         if (file_exists($directory . '/' . $classFile) === FALSE) {
             throw new Admin_Model_Acl_Exception('Controller file could not be found');
         }
         require_once $directory . '/' . $classFile;
         $reflect = new Zend_Reflection_Class($className);
         $CcFilter = new Zend_Filter_Word_CamelCaseToDash();
         foreach ($reflect->getMethods() as $method) {
             if (preg_match('/(\\w+)Action$/', $method->getName(), $match)) {
                 $actionComment = $method->getName();
                 $name = $match[1];
                 $docComment = $method->getDocComment();
                 if (is_string($docComment)) {
                     $commentRows = explode("\n", $docComment);
                     $actionComment = preg_replace("/^\\s*\\*\\s*(.*)\\s*/", '$1', $commentRows[1]);
                     if ($actionComment === "") {
                         $actionComment = $docComment;
                     }
                 }
                 $actions[] = new Admin_Model_DbRow_Action(array('actionName' => strtolower($CcFilter->filter($name)), 'description' => $actionComment));
             }
         }
     } else {
         foreach ($this->hooks as $hook) {
             foreach ($hook->getActions($modul, $controller) as $hAction) {
                 $actions[] = $hAction;
             }
             //$actions = array_merge_recursive($actions, $hook->getActions($modul, $controller));
         }
     }
     return $actions;
 }