/** * * @param string $class * @param array $config * @return ClassAnnotationHolder */ public function parse($class, array $config = array()) { $annotationManager = new AnnotationManager(); $parser = new DoctrineAnnotationParser(); $parser->registerAnnotation(Route::class); $parser->registerAnnotation(Service::class); $parser->registerAnnotation(Controller::class); $parser->registerAnnotation(ControllerPlugin::class); $parser->registerAnnotation(Filter::class); $parser->registerAnnotation(FormElement::class); $parser->registerAnnotation(Hydrator::class); $parser->registerAnnotation(InputFilter::class); $parser->registerAnnotation(LogProcessor::class); $parser->registerAnnotation(LogWriter::class); $parser->registerAnnotation(Route::class); $parser->registerAnnotation(RoutePlugin::class); $parser->registerAnnotation(Serializer::class); $parser->registerAnnotation(Validator::class); $parser->registerAnnotation(ViewHelper::class); $annotationManager->attach($parser); $scanner = new DirectoryScanner('.'); $class = $scanner->getClass($class); $eventManager = new EventManager(); $parser = new ClassParser($config, $annotationManager, $eventManager); return $this->handleClassAnnotations($parser->parseClass($class), $config); }
public function __construct(ClassScanner $classScanner, DirectoryScanner $directoryScanner) { $this->classScanner = $classScanner; $this->directoryScanner = $directoryScanner; $currentScannerClass = $classScanner; while ($currentScannerClass && $currentScannerClass->hasParentClass()) { $currentParentClassName = $currentScannerClass->getParentClass(); //$this->parentClassScanners[$currentParentClassName] = null; if ($directoryScanner->hasClass($currentParentClassName)) { $currentParentClass = $directoryScanner->getClass($currentParentClassName); $this->parentClassScanners[$currentParentClassName] = $currentParentClass; $currentScannerClass = $currentParentClass; } else { $currentScannerClass = false; } } foreach ($interfaces = $this->classScanner->getInterfaces() as $iName) { if ($directoryScanner->hasClass($iName)) { $this->interfaceClassScanners[$iName] = $directoryScanner->getClass($iName); } } }
public function addScanner(DirectoryScanner $scanner) { $this->scanners[] = $scanner; if ($this->isScanned) { $scanner->scan(); } }
public function testCreatesClass() { $ds = new DirectoryScanner(); $ds->addDirectory(__DIR__ . '/TestAsset'); $ads = new AggregateDirectoryScanner(); $ads->addDirectoryScanner($ds); $c = $ads->getClass('ZendTest\\Code\\Scanner\\TestAsset\\MapperExample\\RepositoryB'); $this->assertEquals('ZendTest\\Code\\Scanner\\TestAsset\\MapperExample\\RepositoryB', $c->getName()); }
public function testCreatesClass() { $ds = new DirectoryScanner(); $ds->addDirectory(__DIR__ . '/../TestAsset'); $ads = new AggregateDirectoryScanner(); $ads->addScanner($ds); $c = $ads->getClass('ZendTest\Code\Scanner\TestAsset\MapperExample\RepositoryB'); //echo $c->getName(); //var_dump($c->getMethods(true)); var_dump($c->getProperties()); }
/** * @inheritdoc */ public function fetchAll() { $classes = $this->scanner->getClasses(true); $definitions = []; foreach ($classes as $class) { /* @var DerivedClassScanner $class */ $className = $class->getName(); $matches = []; if (preg_match($this->pattern, $className, $matches) && isset($matches[1]) && $class->isInstantiable()) { $migration = $this->factory->create($className); if ($migration instanceof MigrationInterface) { $definitions[] = new Definition($migration); } } } return $definitions; }
/** * @inheritdoc */ public function doFetchAll() { $versions = new Linked(); $classes = $this->scanner->getClasses(true); foreach ($classes as $class) { /* @var DerivedClassScanner $class */ $className = $class->getName(); $matches = []; if (preg_match($this->pattern, $className, $matches) && isset($matches[1]) && $class->isInstantiable()) { $migration = $this->getMigrationFactory()->create($className); if ($migration instanceof MigrationInterface) { $id = hash('sha1', $className); $version = new LinkedVersion($id, false, $migration); $versions->add($version); } } } return $versions; }
/** * @param ModuleEvent $event * @throws Exception */ public function onMergeConfig(ModuleEvent $event) { // do not parse annotations if config cache is enabled. $config = $event->getConfigListener()->getMergedConfig(false); $parser = ClassParserFactory::factory($config, $event->getTarget()->getEventManager()); $modules = $event->getTarget()->getLoadedModules(); $modulesAllowedToScan = $config['zf_annotation']['scan_modules']; foreach ($modules as $module) { $parts = explode('\\', get_class($module)); $modName = array_shift($parts); if (!empty($modulesAllowedToScan) && !in_array($modName, $modulesAllowedToScan)) { continue; } $ref = new ReflectionClass($module); $dir = dirname($ref->getFileName()); $classes = new DirectoryScanner($dir); $parsedConfig = $parser->parse($classes->getClasses()); } $event->getConfigListener()->setMergedConfig(array_replace_recursive($parsedConfig, $config)); }
/** * @param DirectoryScanner $dirScanner * @return array */ private function findClasses(DirectoryScanner $dirScanner) : array { $classes = $dirScanner->getClasses(); $foundClasses = array(); foreach ($classes as $class) { if ($class->isTrait() === true) { $methods = $class->getMethods(); $parameters = array(); foreach ($methods as $method) { $parameters = array_merge($parameters, $method->getParameters(true)); } } else { $constructor = $class->getMethod("__construct"); if (!$constructor) { continue; } $parameters = $constructor->getParameters(true); } $foundClasses = array_merge($foundClasses, $this->findClassesFromParams($parameters)); } return array_unique($foundClasses); }
/** * @return array */ public function collect() { $classes = array(); /* @var $classesToScan ClassScanner[] */ $classesToScan = $this->directoryScanner->getClasses(); /* @var $classScanner \Zend\Code\Scanner\ClassScanner */ foreach ($classesToScan as $classScanner) { if (!($classArr = $this->collectDataForClass($classScanner, $classesToScan))) { continue; } $classes[$classScanner->getName()] = $classArr; } return $classes; }
/** * Generates a list of Action objects based on the given directory structure, handling * each found class as an invokable service * * @deprecated this logic is deprecated and uses per-directory scanning. Instead, please * map your defined service names in the 'services' config * @param array $modules * @return array * @throws InvalidArgumentException */ protected function buildDirectoryApi(array $modules) { $api = array(); foreach ($modules as $moduleName => $module) { if (!isset($module['directory']) || !is_dir($module['directory'])) { throw new InvalidArgumentException('Invalid directory given: "' . $module['directory'] . '"'); } if (!isset($module['namespace']) || !is_string($module['namespace'])) { throw new InvalidArgumentException('Invalid namespace provided for module "' . $moduleName . '"'); } $jsNamespace = rtrim(str_replace('\\', '.', $module['namespace']), '.') . '.'; $directoryScanner = new DirectoryScanner($module['directory']); /* @var $class \Zend\Code\Scanner\DerivedClassScanner */ foreach ($directoryScanner->getClasses(true) as $class) { // now building the service name as exposed client-side $className = $class->getName(); $jsClassName = str_replace('\\', '.', substr($className, strlen($module['namespace']) + 1)); $jsClassNames = explode('.', $jsClassName); $chunks = count($jsClassNames); // lcfirst all chunks except the last one for ($i = 1; $i < $chunks; $i += 1) { $jsClassNames[$i - 1] = lcfirst($jsClassNames[$i - 1]); } $serviceName = $jsNamespace . implode('.', $jsClassNames); if (!$this->serviceManager->has($serviceName)) { $this->serviceManager->setInvokableClass($serviceName, $className); } // invoking to check if nothing went wrong - this avoids setting invalid services $service = $this->serviceManager->get($serviceName); $action = $this->buildAction(get_class($service)); $action->setName($serviceName); $action->setObjectName($className); $api[$serviceName] = $action; } } return $api; }
/** * Return the parameters for a method * * 3 item array: * #1 - Class name, string if it exists, else null * #2 - Optional?, boolean * #3 - Instantiable, boolean if class exists, otherwise null * * @return array */ public function compileScannerInjectionMethodParmeters(MethodScanner $methodScanner, $introspectionType) { $params = array(); $parameterScanners = $methodScanner->getParameters(true); // rules according to type $rules = $this->getIntrospectionRuleset()->getRules($introspectionType); /* @var $p Zend\Code\Scanner\ParameterScanner */ foreach ($parameterScanners as $p) { $paramName = $p->getName(); // create array for this parameter $params[$paramName] = array(); // get name, and class if it exists $pcName = $p->getClass(); if ($this->directoryScanner->hasClass($pcName)) { $pc = $this->directoryScanner->getClass($pcName); } if ($pcName) { // @todo Should we throw an exception if its an unknown type? $params[$paramName][] = $pcName; } else { $params[$paramName][] = null; } if ($introspectionType == IntrospectionRuleset::TYPE_SETTER && $rules['paramCanBeOptional']) { $params[$paramName][] = true; } else { $params[$paramName][] = $p->isOptional(); } if (isset($pc)) { $params[$paramName][] = ($pc->isInstantiable()) ? true : false; } else { $params[$paramName][] = null; } } return $params; }
/** * 检索指定目录下的全部资源到数据库中 */ private function addResource() { $this->_resource->remove(array()); $scaner = new DirectoryScanner(); $scaner->addDirectory(ROOT_PATH . '/module/Application/src/Application/Controller/'); $scaner->addDirectory(ROOT_PATH . '/module/Idatabase/src/Idatabase/Controller/'); foreach ($scaner->getClasses(true) as $classScanner) { $className = $classScanner->getName(); foreach ($classScanner->getMethods(true) as $method) { if ($this->endsWith($method->getName(), 'Action')) { $actionName = $method->getName(); $docComment = $method->getDocComment(); $docBlockScanner = new DocBlockScanner($docComment); $docAtName = $this->getDocNameValue($docBlockScanner->getTags()); // 写入数据库 $classInfo = $this->parseClassName($className); $this->_resource->insert(array('name' => $docAtName, 'alias' => $className . '\\' . $actionName, 'namespace' => $classInfo['namespace'], 'controller' => $classInfo['controller'], 'action' => $this->parseMethodName($actionName))); } } } }