Example #1
0
 /**
  * Adds a service
  *
  * @param string $id
  * @param Definition $definition
  * @return string
  */
 private function addService($id, $definition)
 {
     $code = "  {$id}:\n";
     if ($definition->getClass()) {
         $code .= sprintf("    class: %s\n", $definition->getClass());
     }
     $tagsCode = '';
     foreach ($definition->getTags() as $name => $tags) {
         foreach ($tags as $attributes) {
             $att = array();
             foreach ($attributes as $key => $value) {
                 $att[] = sprintf('%s: %s', Yaml::dump($key), Yaml::dump($value));
             }
             $att = $att ? ', ' . implode(' ', $att) : '';
             $tagsCode .= sprintf("      - { name: %s%s }\n", Yaml::dump($name), $att);
         }
     }
     if ($tagsCode) {
         $code .= "    tags:\n" . $tagsCode;
     }
     if ($definition->getFile()) {
         $code .= sprintf("    file: %s\n", $definition->getFile());
     }
     if ($definition->getFactoryMethod()) {
         $code .= sprintf("    factory_method: %s\n", $definition->getFactoryMethod());
     }
     if ($definition->getFactoryService()) {
         $code .= sprintf("    factory_service: %s\n", $definition->getFactoryService());
     }
     if ($definition->getArguments()) {
         $code .= sprintf("    arguments: %s\n", Yaml::dump($this->dumpValue($definition->getArguments()), 0));
     }
     if ($definition->getProperties()) {
         $code .= sprintf("    properties: %s\n", Yaml::dump($this->dumpValue($definition->getProperties()), 0));
     }
     if ($definition->getMethodCalls()) {
         $code .= sprintf("    calls:\n      %s\n", str_replace("\n", "\n      ", Yaml::dump($this->dumpValue($definition->getMethodCalls()), 1)));
     }
     if (ContainerInterface::SCOPE_CONTAINER !== ($scope = $definition->getScope())) {
         $code .= sprintf("    scope: %s\n", $scope);
     }
     if ($callable = $definition->getConfigurator()) {
         if (is_array($callable)) {
             if (is_object($callable[0]) && $callable[0] instanceof Reference) {
                 $callable = array($this->getServiceCall((string) $callable[0], $callable[0]), $callable[1]);
             } else {
                 $callable = array($callable[0], $callable[1]);
             }
         }
         $code .= sprintf("    configurator: %s\n", Yaml::dump($callable, 0));
     }
     return $code;
 }
Example #2
0
 /**
  * Creates a service for a service definition.
  *
  * @param  Definition $definition A service definition instance
  * @param  string     $id         The service identifier
  *
  * @return object              The service described by the service definition
  */
 protected function createService(Definition $definition, $id)
 {
     if (null !== $definition->getFile()) {
         require_once self::resolveValue($definition->getFile(), $this->parameters);
     }
     $r = new \ReflectionClass(self::resolveValue($definition->getClass(), $this->parameters));
     $arguments = $this->resolveServices(self::resolveValue($definition->getArguments(), $this->parameters));
     if (null !== $definition->getConstructor()) {
         $service = call_user_func_array(array(self::resolveValue($definition->getClass(), $this->parameters), $definition->getConstructor()), $arguments);
     } else {
         $service = null === $r->getConstructor() ? $r->newInstance() : $r->newInstanceArgs($arguments);
     }
     if ($definition->isShared()) {
         $this->services[$id] = $service;
     }
     foreach ($definition->getMethodCalls() as $call) {
         $services = self::getServiceConditionals($call[1]);
         $ok = true;
         foreach ($services as $s) {
             if (!$this->hasService($s)) {
                 $ok = false;
                 break;
             }
         }
         if ($ok) {
             call_user_func_array(array($service, $call[0]), $this->resolveServices(self::resolveValue($call[1], $this->parameters)));
         }
     }
     if ($callable = $definition->getConfigurator()) {
         if (is_array($callable) && is_object($callable[0]) && $callable[0] instanceof Reference) {
             $callable[0] = $this->getService((string) $callable[0]);
         } elseif (is_array($callable)) {
             $callable[0] = self::resolveValue($callable[0], $this->parameters);
         }
         if (!is_callable($callable)) {
             throw new \InvalidArgumentException(sprintf('The configure callable for class "%s" is not a callable.', get_class($service)));
         }
         call_user_func($callable, $service);
     }
     return $service;
 }
Example #3
0
 protected function createService(Definition $pDefinition)
 {
     // create reflection class
     $rflClass = new \ReflectionClass($pDefinition->getClassName());
     // create service with constructor arguments
     if ($pDefinition->hasConstructArguments() === true) {
         // build constructor arguments
         $constructArguments = $this->buildArguments($pDefinition->getConstructArguments());
         // build service
         $serviceClass = $rflClass->newInstanceArgs($constructArguments);
         // create service without construct arguments
     } else {
         // build service
         $serviceClass = $rflClass->newInstance();
     }
     // call methods on the class
     foreach ($pDefinition->getMethodCalls() as $methodName => $arguments) {
         $this->callMethod($serviceClass, $methodName, $arguments);
     }
     // return service
     return $serviceClass;
 }