public function compileScannerInjectionMethods(ClassScanner $scannerClass) { $data = array(); $className = $scannerClass->getName(); foreach ($scannerClass->getMethods(true) as $scannerMethod) { $methodName = $scannerMethod->getName(); // determine initiator & constructor dependencies if ($methodName === '__construct' && $scannerMethod->isPublic()) { $params = $scannerMethod->getParameters(true); if ($params) { $data[$methodName] = array(); foreach ($params as $param) { $data[$methodName][$param->getName()] = $param->getClass(); } } } // scan for setter injection if (preg_match('#^set[A-Z]#', $methodName)) { $data[$methodName] = $scannerMethod->getParameters(); $params = $scannerMethod->getParameters(true); $data[$methodName] = array(); foreach ($params as $param) { $data[$methodName][$param->getName()] = $param->getClass(); } } } return $data; }
public function handleClassAnnotation(Service $annotation, ClassScanner $class) { if (!$annotation->getName()) { $annotation->setName($class->getName()); } switch ($annotation->getType()) { case 'invokable': $this->definitions[$annotation->getServiceManager()]['invokables'][$annotation->getName()] = $class->getName(); break; case 'factory': if (!in_array(FactoryInterface::class, $class->getInterfaces())) { throw new InvalidAnnotationException('Service factory class must implement "' . FactoryInterface::class . '".'); } $this->definitions[$annotation->getServiceManager()]['factories'][$annotation->getName()] = $class->getName(); break; case 'abstractFactory': if (!in_array(AbstractFactoryInterface::class, $class->getInterfaces())) { throw new InvalidAnnotationException('Abstract service factory class must implement "' . AbstractFactoryInterface::class . '".'); } $this->definitions[$annotation->getServiceManager()]['abstract_factories'][] = $class->getName(); break; case 'initializer': if (!in_array(InitializerInterface::class, $class->getInterfaces())) { throw new InvalidAnnotationException('Initializer must implement "' . InitializerInterface::class . '".'); } $this->definitions[$annotation->getServiceManager()]['initializers'][] = $class->getName(); break; case 'delegator': if (!in_array(DelegatorFactoryInterface::class, $class->getInterfaces())) { throw new InvalidAnnotationException('Delegator must implement "' . DelegatorFactoryInterface::class . '".'); } if (empty($annotation->getFor())) { throw new InvalidAnnotationException('Delegator annotation must contain "for" option.'); } if (!isset($this->definitions[$annotation->getServiceManager()]['delegators'][$annotation->getFor()])) { $this->definitions[$annotation->getServiceManager()]['delegators'][$annotation->getFor()] = array(); } $this->definitions[$annotation->getServiceManager()]['delegators'][$annotation->getFor()][] = $class->getName(); break; default: throw new InvalidAnnotationException('Service annotation must have "type" property value. Seen in ' . $class->getName()); } $allowedToShareAndAlias = array('invokable', 'factory'); if (in_array($annotation->getType(), $allowedToShareAndAlias)) { if (is_bool($annotation->getShared())) { $this->definitions[$annotation->getServiceManager()]['shared'][$annotation->getName()] = $annotation->getShared(); } foreach ($annotation->getAliases() as $alias) { $this->definitions[$annotation->getServiceManager()]['aliases'][$alias] = $annotation->getName(); } } }
/** * Retrieve class footprint from class scanner * * @param ClassScanner $class * * @return ClassFootprint */ protected function getClassFootprint(ClassScanner $class) { $footprint = new ClassFootprint(); if ($class->isInterface()) { $footprint->setType(ClassFootprint::TYPE_INTERFACE); } elseif ($class->isTrait()) { $footprint->setType(ClassFootprint::TYPE_TRAIT); } $footprint->setParent($class->getParentClass()); foreach ($class->getConstants(false) as $constant) { $footprint->addConstant($constant->getName(), $constant->getValue()); } foreach ($class->getInterfaces() as $interface) { $footprint->addInterface($interface); } return $footprint; }
/** * @param string $name * @return bool */ public function hasMethod($name) { if ($this->classScanner->hasMethod($name)) { return true; } foreach ($this->parentClassScanners as $pClassScanner) { if ($pClassScanner->hasMethod($name)) { return true; } } return false; }
/** * * @param ClassScanner $class * @return ClassAnnotationHolder */ public function parseClass(ClassScanner $class) { $classAnnotationHolder = new ClassAnnotationHolder($class); $classAnnotations = $class->getAnnotations($this->annotationManager); if ($classAnnotations instanceof AnnotationCollection) { foreach ($classAnnotations as $annotation) { $classAnnotationHolder->addAnnotation($annotation); } } else { $classAnnotations = new AnnotationCollection(array()); } foreach ($class->getMethods() as $method) { // zf can't process abstract methods for now, wrap with "try" block $methodAnnotationHolder = new MethodAnnotationHolder($method); $methodAnnotations = $method->getAnnotations($this->annotationManager); if ($methodAnnotations instanceof AnnotationCollection) { foreach ($methodAnnotations as $annotation) { $methodAnnotationHolder->addAnnotation($annotation); } } $classAnnotationHolder->addMethod($methodAnnotationHolder); } return $classAnnotationHolder; }
/** * @param ClassScanner $classScanner * @param ClassScanner[] $allClasses * @return array | false */ protected function collectDataForClass(ClassScanner $classScanner, array $allClasses) { if ($classScanner->isInterface() || $classScanner->isAbstract()) { return false; } $classArr = array('properties' => array()); $classArr = array_merge($classArr, $this->processClassAnnotations($classScanner)); return array_merge($classArr, $this->processPropertiesAnnotations($classScanner, $allClasses)); }
/** * @param AnnotationInterface $annotation * @param ClassScanner $class * @throws InvalidArgumentException */ public function annotationToRouteConfig(AnnotationInterface $annotation, ClassScanner $class, MethodScanner $method = null) { $method = $method ?: 'index'; $annotation = $this->guessMissingFields($annotation, $method, $class->getName()); $routeConfig = $this->getRouteConfig($annotation); if ($annotation->getExtends()) { $tmp = array(); $ref =& $this->getReferenceForPath(explode('/', $annotation->getExtends()), $tmp); $ref = $routeConfig; return $tmp; } else { return $routeConfig; } }