/**
*
* @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)));
}
}
}
}