/**
* {@inheritdoc}
* @throws PropertyDefinitionNotFoundException
*/
public function analyze(DefinitionAnalyzer $analyzer, ClassDefinition $classDefinition, \ReflectionProperty $reflectionProperty)
{
$propertyName = $reflectionProperty->getName();
// Set property metadata
if ($classDefinition->hasProperty($propertyName)) {
$classDefinition->getProperty($propertyName)->setIsPublic($reflectionProperty->isPublic())->setModifiers($reflectionProperty->getModifiers());
}
}
/**
* {@inheritdoc}
* @throws MethodDefinitionAlreadyExistsException
* @throws MethodDefinitionNotFoundException
*/
public function analyze(DefinitionAnalyzer $analyzer, ClassDefinition $classDefinition, \ReflectionMethod $reflectionMethod)
{
$methodName = $reflectionMethod->getName();
// Constructor definition is required
if ($methodName === '__construct' && !$classDefinition->hasMethod('__construct')) {
$classDefinition->defineConstructor()->end();
}
// Set method metadata
if ($classDefinition->hasMethod($methodName)) {
$classDefinition->getMethod($methodName)->setModifiers($reflectionMethod->getModifiers())->setIsPublic($reflectionMethod->isPublic());
}
}
/**
* {@inheritdoc}
* @throws PropertyDefinitionAlreadyExistsException
* @throws PropertyDefinitionNotFoundException
*/
public function analyze(DefinitionAnalyzer $analyzer, ClassDefinition $classDefinition, \ReflectionProperty $reflectionProperty)
{
$propertyName = $reflectionProperty->getName();
// Resolve annotations
$annotations = $this->reader->getPropertyAnnotations($reflectionProperty);
if (count($annotations)) {
// Define property if not exists
if (!$classDefinition->hasProperty($propertyName)) {
$classDefinition->defineProperty($propertyName);
}
// Exec annotations
foreach ($annotations as $annotation) {
if ($annotation instanceof ResolvePropertyInterface) {
$annotation->resolveProperty($analyzer, $classDefinition, $reflectionProperty);
}
}
}
}
/**
* {@inheritdoc}
* @throws ParameterDefinitionAlreadyExistsException
* @throws ReferenceNotImplementsException
* @throws MethodDefinitionNotFoundException
* @throws ParameterDefinitionNotFoundException
* @throws \InvalidArgumentException
*/
public function analyze(DefinitionAnalyzer $analyzer, ClassDefinition $classDefinition, \ReflectionParameter $reflectionParameter)
{
$methodName = $reflectionParameter->getDeclaringFunction()->getName();
$parameterName = $reflectionParameter->getName();
// Define parameter only if method definition is available
if ($classDefinition->hasMethod($methodName)) {
$methodDefinition = $classDefinition->getMethod($methodName);
// Define parameter definition if not exists
$parameterDefinition = $methodDefinition->setupParameter($parameterName);
$this->setReflectionMetadata($parameterDefinition, $reflectionParameter);
$dependency = $parameterDefinition->getDependency();
// If dependency was not set
// UndefinedReference is the default value of dependency which was not use before
if (!$dependency || $dependency instanceof UndefinedReference) {
$this->setDependencyByReflection($parameterDefinition, $reflectionParameter);
}
$this->setOrderArguments($methodDefinition, $reflectionParameter->getDeclaringFunction());
}
}
/**
* {@inheritdoc}
* @throws MethodDefinitionAlreadyExistsException
*/
public function analyze(DefinitionAnalyzer $analyzer, ClassDefinition $classDefinition, \ReflectionMethod $reflectionMethod)
{
$methodName = $reflectionMethod->getName();
// Resolve annotations
$annotations = $this->reader->getMethodAnnotations($reflectionMethod);
// Create method definition if annotation is exists
if (count($annotations)) {
// Define method if not exists
if (!$classDefinition->hasMethod($methodName)) {
$classDefinition->defineMethod($methodName);
}
// Exec method annotations
foreach ($annotations as $annotation) {
if ($annotation instanceof ResolveMethodInterface) {
$annotation->resolveMethod($analyzer, $classDefinition, $reflectionMethod);
}
}
}
}
/**
* Generate return operator and save instance to static properties it its singleton
*
* @param ClassDefinition $classDefinition
* @param string $id
* @return string
*/
protected function generateReturnOperator(ClassDefinition $classDefinition, string $id = null) : string
{
$code = "\treturn \$temp;";
// If there is a singleton then save it to static service collection
if ($classDefinition->isSingleton()) {
$code = "\t\$singletonCollection['{$id}'] = \$temp;\n\t\t" . $code;
}
return $code;
}
/**
* Add new class definition
*
* @param $className
* @param string $serviceName
* @return ClassBuilderInterface
* @throws \InvalidArgumentException
* @throws ClassDefinitionAlreadyExistsException
*/
public function addDefinition($className, string $serviceName = null) : ClassBuilderInterface
{
// Check if class already exists
if ($this->hasDefinition($className)) {
throw new ClassDefinitionAlreadyExistsException();
}
// Create new definition
$classDefinition = new ClassDefinition($this);
$classDefinition->setClassName(new ClassReference($className));
if ($serviceName) {
$classDefinition->setServiceName($serviceName);
}
// Register definition
$this->definitionCollection[$className] = $classDefinition;
return $classDefinition;
}
/**
* {@inheritdoc}
* @throws WrongAnnotationConstructorException
* @throws MethodDefinitionNotFoundException
* @throws ParameterDefinitionAlreadyExistsException
* @throws MethodDefinitionAlreadyExistsException
*/
public function resolveMethod(DefinitionAnalyzer $analyzer, ClassDefinition $classDefinition, \ReflectionMethod $reflectionMethod)
{
// Get parameter key
$key = array_keys($this->value)[0];
$classDefinition->setupMethod($reflectionMethod->getName())->defineParameter($key)->defineDependency(new ClassReference($this->value[$key]))->end();
}
/** {@inheritdoc} */
public function resolveClass(DefinitionAnalyzer $analyzer, ClassDefinition $classDefinition, \ReflectionClass $reflectionClass)
{
$classDefinition->setServiceName($this->value['value']);
$classDefinition->setIsSingleton(true);
}
/** {@inheritdoc} */
public function analyze(DefinitionAnalyzer $analyzer, ClassDefinition $classDefinition, \ReflectionClass $reflectionClass)
{
// Get name space from class name
$classDefinition->setNameSpace($reflectionClass->getNamespaceName());
}
/**
* Resolve method
*
* @param ClassDefinition $classDefinition
* @param array $methodArray
* @param string $methodName
* @throws MethodDefinitionAlreadyExistsException
* @throws \InvalidArgumentException
* @throws ParameterDefinitionAlreadyExistsException
* @throws ReferenceNotImplementsException
*/
protected function resolveMethod(ClassDefinition $classDefinition, array $methodArray, string $methodName)
{
$methodDefinition = $classDefinition->defineMethod($methodName);
if (array_key_exists('arguments', $methodArray)) {
$this->resolveArguments($methodDefinition, $methodArray['arguments']);
}
}
/**
* Define constructor
*
* @param ClassDefinition $classDefinition
* @param $path
* @throws MethodDefinitionAlreadyExistsException
*/
protected function defineConstructor(ClassDefinition $classDefinition, $path)
{
$classDefinition->defineConstructor()->defineParameter('path')->defineDependency(new StringReference($path))->end()->end();
}
