private function dumpMethods($className, ClassDefinition $definition) { $str = ''; foreach ($definition->getMethodInjections() as $methodInjection) { $parameters = $this->dumpMethodParameters($className, $methodInjection); $str .= sprintf("\n %s(\n %s\n )", $methodInjection->getMethodName(), $parameters); } return $str; }
/** * {@inheritdoc} */ public function getDefinition($name, MergeableDefinition $parentDefinition = null) { // Only merges with class definition if ($parentDefinition && !$parentDefinition instanceof ClassDefinition) { return null; } $className = $parentDefinition ? $parentDefinition->getClassName() : $name; if (!class_exists($className) && !interface_exists($className)) { return null; } $class = new ReflectionClass($className); $definition = new ClassDefinition($name); // Constructor $constructor = $class->getConstructor(); if ($constructor && $constructor->isPublic()) { $definition->setConstructorInjection($this->getConstructorInjection($constructor)); } // Merge with parent if ($parentDefinition) { $definition = $parentDefinition->merge($definition); } return $definition; }
/** * Fixes parameters indexed by the parameter name -> reindex by position. * * This is necessary so that merging definitions between sources is possible. * * @param ClassDefinition $definition * @param string $method * @param array $parameters * @return array */ private function fixParameters(ClassDefinition $definition, $method, $parameters) { $fixedParameters = array(); foreach ($parameters as $index => $parameter) { // Parameter indexed by the parameter name, we reindex it with its position if (is_string($index)) { $callable = array($definition->getClassName(), $method); $reflectionParameter = new \ReflectionParameter($callable, $index); $index = $reflectionParameter->getPosition(); } $fixedParameters[$index] = $parameter; } return $fixedParameters; }
/** * @param ClassDefinition $definition * @param object $instance * @param ClassDefinition $classDefinition */ private function injectMethodsAndProperties(ClassDefinition $definition, $instance, ClassDefinition $classDefinition) { // Property injections foreach ($classDefinition->getPropertyInjections() as $propertyInjection) { $this->injectProperty($instance, $propertyInjection); } // Method injections foreach ($classDefinition->getMethodInjections() as $methodInjection) { $this->injectMethod($definition, $instance, $methodInjection); } }
private function assertClassExists(ClassDefinition $classDefinition) { if (!class_exists($classDefinition->getClassName()) && !interface_exists($classDefinition->getClassName())) { throw DefinitionException::create($classDefinition, sprintf("Entry %s cannot be resolved: class %s doesn't exist", $classDefinition->getName(), $classDefinition->getClassName())); } }
/** * Browse the object's methods looking for annotated methods. * * @param ReflectionClass $class * @param ClassDefinition $classDefinition */ private function readMethods(ReflectionClass $class, ClassDefinition $classDefinition) { // This will look in all the methods, including those of the parent classes foreach ($class->getMethods(ReflectionMethod::IS_PUBLIC) as $method) { if ($method->isStatic()) { continue; } $methodInjection = $this->getMethodInjection($method); if (!$methodInjection) { continue; } if ($method->isConstructor()) { $classDefinition->setConstructorInjection($methodInjection); } else { $classDefinition->addMethodInjection($methodInjection); } } }
private function readInjectableAnnotation(ReflectionClass $class, ClassDefinition $definition) { try { /** @var $annotation Injectable|null */ $annotation = $this->getAnnotationReader()->getClassAnnotation($class, 'DI\\Annotation\\Injectable'); } catch (UnexpectedValueException $e) { throw new DefinitionException(sprintf('Error while reading @Injectable on %s: %s', $class->getName(), $e->getMessage()), 0, $e); } if (!$annotation) { return; } if ($annotation->getScope()) { $definition->setScope($annotation->getScope()); } if ($annotation->isLazy() !== null) { $definition->setLazy($annotation->isLazy()); } }