protected function reflectDefinition($reflClass) { $definition = new Definition($reflClass->getName()); if ($annot = $this->reader->getClassAnnotation($reflClass, 'LoSo\\Symfony\\Component\\DependencyInjection\\Loader\\Annotation\\Service')) { $id = $this->extractServiceName($reflClass, $annot); if (isset($annot->shared)) { $definition->setShared($annot->shared); } if (isset($annot->factoryMethod)) { $definition->setFactoryMethod($annot->factoryMethod); } if (isset($annot->factoryService)) { $definition->setFactoryService($annot->factoryService); } foreach ($annot->tags as $tag) { $name = $tag['name']; unset($tag['name']); $definition->addTag($name, $tag); } $this->reflectProperties($reflClass, $definition); $this->reflectMethods($reflClass, $definition); $this->reflectConstructor($reflClass, $definition); $this->container->setDefinition($id, $definition); } }
/** * Loads a configured DBAL connection. * * @param string $name The name of the connection * @param array $connection A dbal connection configuration. * @param ContainerBuilder $container A ContainerBuilder instance */ protected function loadDbalConnection($name, array $connection, ContainerBuilder $container) { $containerDef = new Definition('%doctrine.dbal.configuration_class%'); $containerDef->setPublic(false); if (isset($connection['logging']) && $connection['logging']) { $containerDef->addMethodCall('setSQLLogger', array(new Reference('doctrine.dbal.logger'))); unset($connection['logging']); } $container->setDefinition(sprintf('doctrine.dbal.%s_connection.configuration', $name), $containerDef); $driverDef = new Definition('Doctrine\\DBAL\\Connection'); $driverDef->setFactoryService('doctrine.dbal.connection_factory'); $driverDef->setFactoryMethod('createConnection'); $container->setDefinition(sprintf('doctrine.dbal.%s_connection', $name), $driverDef); // event manager $eventManagerId = sprintf('doctrine.dbal.%s_connection.event_manager', $name); $eventManagerDef = new Definition('%doctrine.dbal.event_manager_class%'); $eventManagerDef->setPublic(false); $container->setDefinition($eventManagerId, $eventManagerDef); if (isset($connection['charset'])) { if (isset($connection['driver']) && stripos($connection['driver'], 'mysql') !== false || isset($connection['driverClass']) && stripos($connection['driverClass'], 'mysql') !== false) { $mysqlSessionInit = new Definition('%doctrine.dbal.events.mysql_session_init.class%'); $mysqlSessionInit->setArguments(array($connection['charset'])); $mysqlSessionInit->setPublic(false); $mysqlSessionInit->addTag(sprintf('doctrine.dbal.%s_event_subscriber', $name)); $container->setDefinition(sprintf('doctrine.dbal.%s_connection.events.mysqlsessioninit', $name), $mysqlSessionInit); unset($connection['charset']); } } if (isset($connection['platform_service'])) { $connection['platform'] = new Reference($connection['platform_service']); unset($connection['platform_service']); } $driverDef->setArguments(array($connection, new Reference(sprintf('doctrine.dbal.%s_connection.configuration', $name)), new Reference(sprintf('doctrine.dbal.%s_connection.event_manager', $name)))); }
/** * {@inheritDoc} */ public function load(array $configs, ContainerBuilder $container) { $loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config')); $loader->load('services.yml'); $configuration = new Configuration(); $config = $this->processConfiguration($configuration, $configs); $def = $container->getDefinition('socloz.nsq'); if ($config['lookupd_hosts']) { $container->setDefinition('socloz.nsq.lookup', new Definition('nsqphp\\Lookup\\Nsqlookupd', array($config['lookupd_hosts']))); } $def->addMethodCall('setDelayedMessagesTopic', array($config['delayed_messages_topic'])); $def->addMethodCall('setStubMode', array($config['stub'])); foreach ($config['topics'] as $name => $conf) { $def->addMethodCall('setTopic', array($name, $conf)); if ($conf['consumers']) { foreach ($conf['consumers'] as $channel => $service) { $def->addMethodCall('setTopicConsumer', array($name, $channel, new Reference($service))); } } $tsd = new Definition('Socloz\\NsqBundle\\Topic\\Topic', array($name)); $tsd->setFactoryService('socloz.nsq'); $tsd->setFactoryMethod('getTopic'); $container->setDefinition('socloz.nsq.topic.' . $name, $tsd); } }
public function getEntityMetadataDefinition($entity, $entityManager) { $definition = new Definition('Doctrine\\ORM\\Mapping\\ClassMetadata'); $definition->setFactoryService($this->resolveEntityManagerId($entityManager)); $definition->setFactoryMethod('getClassMetadata'); $definition->setArguments(array($entity)); return $definition; }
private function buildUseCaseProxyFactoryDefinition($taggedServiceName, $tagParameters) { $definition = $this->container->findDefinition($taggedServiceName); $factoryDefinition = new Definition(); $factoryDefinition->setFactoryService('openclassrooms.use_case.use_case_proxy_factory'); $factoryDefinition->setFactoryMethod('create'); $factoryDefinition->setArguments(array($definition, $tagParameters[0])); $this->container->setDefinition($taggedServiceName, $factoryDefinition); }
protected function prepareRepositoriesServices($classes, ContainerBuilder $container, $appName) { foreach (array_keys($classes) as $model) { $repositoryClassKey = $this->getParameterName($appName, 'repository', $model); $repositoryClass = $container->getParameter($repositoryClassKey); $repositoryDefinition = new Definition($repositoryClass); $repositoryDefinition->setFactoryService('doctrine.orm.entity_manager')->setFactoryMethod('getRepository')->setArguments([$container->getParameter($this->getParameterName($appName, 'model', $model))]); $container->setDefinition($appName . '.repository.' . $model, $repositoryDefinition); } }
public function testProcessDetectsReferencesFromInlinedFactoryDefinitions() { $container = new ContainerBuilder(); $container->register('a'); $factory = new Definition(); $factory->setFactoryService('a'); $container->register('b')->addArgument($factory); $graph = $this->process($container); $this->assertTrue($graph->hasNode('a')); $this->assertCount(1, $refs = $graph->getNode('a')->getInEdges()); }
public function resolveString($value, array $resolved = array()) { if (preg_match('/\\&([^\\&\\s]+)\\&$/', $value, $match)) { $definition = new Definition(); $definition->setFactoryService('service_container'); $definition->setFactoryMethod('getVariable'); $definition->setArguments(array($match[1])); return $definition; } return $value; }
/** * @group legacy */ public function testResolveFactoryService() { $container = new ContainerBuilder(); $container->register('factory', 'Factory'); $container->setAlias('factory_alias', new Alias('factory')); $foo = new Definition(); $foo->setFactoryService('factory_alias'); $foo->setFactoryMethod('createFoo'); $container->setDefinition('foo', $foo); $this->process($container); $this->assertSame('factory', $foo->getFactoryService()); }
/** * @param ContainerBuilder $container * @param $gatewayName * @param array $config * * @return Definition */ protected function createGateway(ContainerBuilder $container, $gatewayName, array $config) { $gatewayFactoryClass = $this->getPayumGatewayFactoryClass(); if (false == class_exists($gatewayFactoryClass)) { throw new RuntimeException(sprintf('Cannot find gateway factory class. Have you installed %s or payum/payum package?', $this->getComposerPackage())); } $config['payum.gateway_name'] = $gatewayName; $gateway = new Definition('Payum\\Core\\Gateway', array($config)); $gateway->setFactoryService(sprintf('payum.%s.factory', $this->getName())); $gateway->setFactoryMethod('create'); return $gateway; }
/** * {@inheritdoc} */ protected function getRepositoryDefinition(array $classes) { $repositoryClass = 'Sylius\\Bundle\\ResourceBundle\\Doctrine\\ODM\\MongoDB\\DocumentRepository'; if (isset($classes['repository'])) { $repositoryClass = $classes['repository']; } $unitOfWorkDefinition = new Definition('Doctrine\\ODM\\MongoDB\\UnitOfWork'); $unitOfWorkDefinition->setFactoryService($this->getManagerServiceKey())->setFactoryMethod('getUnitOfWork')->setPublic(false); $definition = new Definition($repositoryClass); $definition->setArguments(array(new Reference($this->getContainerKey('manager')), $unitOfWorkDefinition, $this->getClassMetadataDefinition($classes['model']))); return $definition; }
protected function loadClientConnection($name, array $connection, ContainerBuilder $container) { $container->setDefinition(sprintf('doctrine_couchdb.client.%s_connection', $name), new DefinitionDecorator('doctrine_couchdb.client.connection'))->setArguments(array($connection)); if (isset($connection['logging']) && $connection['logging'] === true) { $def = new Definition('Doctrine\\CouchDB\\HTTP\\Client'); $def->setFactoryService(sprintf('doctrine_couchdb.client.%s_connection', $name)); $def->setFactoryMethod('getHttpClient'); $def->setPublic(false); $container->setDefinition(sprintf('doctrine_couchdb.httpclient.%s_client', $name), $def); $def = $container->getDefinition('doctrine_couchdb.datacollector'); $def->addMethodCall('addLoggingClient', array(new Reference(sprintf('doctrine_couchdb.httpclient.%s_client', $name)), $name)); } }
/** * {@inheritDoc} */ public function load(array $configs, ContainerBuilder $container) { $configuration = new Configuration(); $config = $this->processConfiguration($configuration, $configs); $container->setParameter('kalamu_menu_service.menus', $config); foreach ($config as $name => $infos) { $definition = new Definition('Knp\\Menu\\MenuItem', array($name)); $definition->setFactoryService('kalamu_menu_service.menu_builder'); $definition->setFactoryMethod('createMenu'); $definition->addTag('knp_menu.menu', array('alias' => $name)); $container->setDefinition('kalamu_menu_service.menu.' . $name, $definition); } $loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config')); $loader->load('services.yml'); }
/** * return from local cache or make a new one and put it in cache and then return it. * @param ContainerBuilder $container * @param string $contextName * @returns Reference The service definition reference */ private function getServiceFactory(ContainerBuilder $container, $contextName) { if (!array_key_exists($contextName, $this->serviceDefinistions)) { $def = new Definition(); $def->setClass('TechData\\ContextDiBundle\\Models\\Context'); $def->setLazy(TRUE); $def->setFactoryService('tech_data_context_di.context_handler'); $def->setFactoryMethod('getContext'); $def->setArguments(array($contextName)); $id = 'tech_data_context_di.contexts.' . $contextName; $container->setDefinition($id, $def); $this->serviceDefinistions[$contextName] = new Reference($id); } return $this->serviceDefinistions[$contextName]; }
/** * {@inheritdoc} */ protected function getRepositoryDefinition(array $classes) { $reflection = new \ReflectionClass($classes['model']); $translatableInterface = 'Sylius\\Component\\Translation\\Model\\TranslatableInterface'; $translatable = interface_exists($translatableInterface) && $reflection->implementsInterface($translatableInterface); $repositoryClass = $translatable ? 'Sylius\\Bundle\\TranslationBundle\\Doctrine\\ODM\\MongoDB\\TranslatableResourceRepository' : new Parameter('sylius.mongodb_odm.repository.class'); if (isset($classes['repository'])) { $repositoryClass = $classes['repository']; } $unitOfWorkDefinition = new Definition('Doctrine\\ODM\\MongoDB\\UnitOfWork'); $unitOfWorkDefinition->setFactoryService($this->getManagerServiceKey())->setFactoryMethod('getUnitOfWork')->setPublic(false); $definition = new Definition($repositoryClass); $definition->setArguments(array(new Reference($this->getContainerKey('manager')), $unitOfWorkDefinition, $this->getClassMetadataDefinition($classes['model']))); return $definition; }
/** * {@inheritDoc} */ protected function addApis(Definition $paymentDefinition, ContainerBuilder $container, $contextName, array $config) { $gatewayDefinition = new Definition(); $gatewayDefinition->setClass('Omnipay\\Common\\GatewayInterface'); $gatewayDefinition->setFactoryService('payum.omnipay_bridge.gateway_factory'); $gatewayDefinition->setFactoryMethod('create'); $gatewayDefinition->addArgument($config['type']); $gatewayDefinition->setPublic(true); foreach ($config['options'] as $name => $value) { $gatewayDefinition->addMethodCall('set' . strtoupper($name), array($value)); } $gatewayId = 'payum.context.' . $contextName . '.gateway'; $container->setDefinition($gatewayId, $gatewayDefinition); $paymentDefinition->addMethodCall('addApi', array(new Reference($gatewayId))); }
/** * Create gateway service. * * @param ContainerBuilder $container * @param string $name * @param array $parameters */ public function createGatewayService(ContainerBuilder $container, $name, array $parameters) { $type = $parameters['type']; $class = trim(Helper::getGatewayClassName($type), "\\"); $definition = new Definition($class); $definition->setFactoryService('sylius.omnipay.gateway_factory')->setFactoryMethod('create')->setArguments(array($type)); $reflection = new \ReflectionClass($class); foreach ($parameters['options'] as $optionName => $value) { $method = 'set' . ucfirst($optionName); if ($reflection->hasMethod($method)) { $definition->addMethodCall($method, array($value)); } } $container->setDefinition(sprintf('sylius.omnipay.gateway.%s', $name), $definition); $this->gateways[$name] = isset($parameters['label']) ? $parameters['label'] : $name; }
public function getFactoryServiceAndFactoryMethodAreDefinedData() { $factoryService = 'factory'; $factoryClass = 'Matthias\\SymfonyServiceDefinitionValidator\\Tests\\Fixtures\\FactoryClass'; $factoryMethod = 'create'; $expectedConstructor = new \ReflectionMethod($factoryClass, $factoryMethod); $definition = new Definition(); $definition->setFactoryService($factoryService); $definition->setFactoryMethod($factoryMethod); $data = array(array($factoryClass, $definition, $expectedConstructor)); if (method_exists($definition, 'setFactory')) { $definition = new Definition(); $definition->setFactory(array(new Reference($factoryService), $factoryMethod)); $data[] = array($factoryClass, $definition, $expectedConstructor); } return $data; }
/** * {@inheritDoc} */ public function load(array $configs, ContainerBuilder $container) { $configuration = new Configuration(); $config = $this->processConfiguration($configuration, $configs); $loader = new Loader\XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config')); if (!empty($config['definitions'])) { $container->setParameter('markup_barcode.definition.configuration', $config['definitions']); foreach ($config['definitions'] as $name => $params) { $generator = new Definition('%markup_barcode.generator.class%', array($name)); $generator->setFactoryService('markup_barcode.generator.provider'); $generator->setFactoryMethod('getNamedGenerator'); $container->setDefinition(sprintf('markup_barcode.generator.%s', $name), $generator); } } else { $container->setParameter('markup_barcode.definition.configuration', array()); } $loader->load('services.xml'); }
/** * Process compilation of containers. * * @param ContainerBuilder $container */ public function process(ContainerBuilder $container) { $factory = $container->findDefinition('app.doctrine.repository.factory'); $repositories = []; foreach ($container->findTaggedServiceIds('app.repository') as $id => $params) { foreach ($params as $param) { $repositories[$param['class']] = $id; $repository = $container->findDefinition($id); $repository->replaceArgument(0, new Reference('doctrine.orm.default_entity_manager')); $definition = new Definition(); $definition->setClass('Doctrine\\ORM\\Mapping\\ClassMetadata'); $definition->setFactoryService('doctrine.orm.default_entity_manager'); $definition->setFactoryMethod('getClassMetadata'); $definition->setArguments([$param['class']]); $repository->replaceArgument(1, $definition); } } $factory->replaceArgument(0, $repositories); $container->findDefinition('doctrine.orm.configuration')->addMethodCall('setRepositoryFactory', [$factory]); }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { $definitions = $container->findTaggedServiceIds('ongr_settings.setting_aware'); foreach ($definitions as $serviceId => $tags) { $definition = $container->getDefinition($serviceId); $initialTags = $definition->getTags(); $definition->clearTags(); $container->setDefinition("{$serviceId}_base", $definition); $callMap = []; foreach ($tags as $tag) { $callMap[$tag['setting']] = isset($tag['method']) ? $tag['method'] : null; } $proxy = new Definition($definition->getClass(), [$callMap, new Reference("{$serviceId}_base")]); $proxy->setFactoryService('ongr_settings.setting_aware_service_factory'); $proxy->setFactoryMethod('get'); unset($initialTags['ongr_settings.setting_aware']); $proxy->setTags($initialTags); $container->setDefinition($serviceId, $proxy); } }
private function getAllParameters() { $service = new Definition(); $service->setClass('stdClass'); $service->setAbstract(true); $service->setFactoryClass('stdClass'); $service->setFactoryMethod('get'); $service->setFactoryService('service.fact'); $service->setFile('/file.php'); $service->setLazy(true); $service->addMethodCall('methodCall1'); $service->addMethodCall('methodCall2', array('arg1', 'arg2')); $service->addMethodCall('methodCall3', array(new Reference('arg.one'))); $service->setProperty('prop1', 'val1'); $service->setProperty('prop2', new Reference('prop.one')); $service->setPublic(false); $service->setScope('request'); $service->setSynchronized(true); $service->setSynthetic(true); return new ServiceElement('service.two', $service); }
/** * {@inheritDoc} */ public function createPayment(ContainerBuilder $container, $gatewayName, array $config) { if (isset($config['service'])) { return new DefinitionDecorator($config['service']); } $config['payum.factory'] = $this->getName(); $config['payum.context'] = $gatewayName; $payment = new Definition('Payum\\Core\\Payment', array($config)); $payment->setFactoryService('payum.payment_factory'); $payment->setFactoryMethod('create'); $captureActionClass = 'Acme\\OtherExamplesBundle\\Payum\\FooBarGateway\\Action\\CaptureAction'; $captureActionDefinition = new Definition($captureActionClass); $captureActionDefinition->addArgument($config['username']); $captureActionDefinition->addArgument($config['password']); $captureActionId = 'payum.foobar_gateway.action.capture'; $container->setDefinition($captureActionId, $captureActionDefinition); $statusActionClass = 'Acme\\OtherExamplesBundle\\Payum\\FooBarGateway\\Action\\StatusAction'; $statusActionDefinition = new Definition($statusActionClass); $statusActionId = 'payum.foobar_gateway.action.status'; $container->setDefinition($statusActionId, $statusActionDefinition); $payment->addMethodCall('addAction', array(new Reference($captureActionId))); $payment->addMethodCall('addAction', array(new Reference($statusActionId))); return $payment; }
private function buildHandler(ContainerBuilder $container, $name, array $handler) { $handlerId = $this->getHandlerId($name); $definition = new Definition(sprintf('%%monolog.handler.%s.class%%', $handler['type'])); $handler['level'] = is_int($handler['level']) ? $handler['level'] : constant('Monolog\Logger::'.strtoupper($handler['level'])); switch ($handler['type']) { case 'service': $container->setAlias($handlerId, $handler['id']); return $handlerId; case 'stream': $definition->setArguments(array( $handler['path'], $handler['level'], $handler['bubble'], )); break; case 'firephp': $definition->setArguments(array( $handler['level'], $handler['bubble'], )); $definition->addTag('kernel.event_listener', array('event' => 'kernel.response', 'method' => 'onKernelResponse')); break; case 'rotating_file': $definition->setArguments(array( $handler['path'], $handler['max_files'], $handler['level'], $handler['bubble'], )); break; case 'fingers_crossed': $handler['action_level'] = is_int($handler['action_level']) ? $handler['action_level'] : constant('Monolog\Logger::'.strtoupper($handler['action_level'])); $nestedHandlerId = $this->getHandlerId($handler['handler']); $this->nestedHandlers[] = $nestedHandlerId; $definition->setArguments(array( new Reference($nestedHandlerId), $handler['action_level'], $handler['buffer_size'], $handler['bubble'], $handler['stop_buffering'], )); break; case 'buffer': $nestedHandlerId = $this->getHandlerId($handler['handler']); $this->nestedHandlers[] = $nestedHandlerId; $definition->setArguments(array( new Reference($nestedHandlerId), $handler['buffer_size'], $handler['level'], $handler['bubble'], )); break; case 'group': $references = array(); foreach ($handler['members'] as $nestedHandler) { $nestedHandlerId = $this->getHandlerId($nestedHandler); $this->nestedHandlers[] = $nestedHandlerId; $references[] = new Reference($nestedHandlerId); } $definition->setArguments(array( $references, $handler['bubble'], )); break; case 'syslog': $definition->setArguments(array( $handler['ident'], $handler['facility'], $handler['level'], $handler['bubble'], )); break; case 'swift_mailer': if (isset($handler['email_prototype'])) { if (!empty($handler['email_prototype']['method'])) { $prototype = array(new Reference($handler['email_prototype']['id']), $handler['email_prototype']['method']); } else { $prototype = new Reference($handler['email_prototype']['id']); } } else { $message = new Definition('Swift_Message'); $message->setFactoryService('mailer'); $message->setFactoryMethod('createMessage'); $message->setPublic(false); $message->addMethodCall('setFrom', array($handler['from_email'])); $message->addMethodCall('setTo', array($handler['to_email'])); $message->addMethodCall('setSubject', array($handler['subject'])); $messageId = sprintf('%s.mail_prototype', $handlerId); $container->setDefinition($messageId, $message); $prototype = new Reference($messageId); } $definition->setArguments(array( new Reference('mailer'), $prototype, $handler['level'], $handler['bubble'], )); break; case 'native_mailer': $definition->setArguments(array( $handler['to_email'], $handler['subject'], $handler['from_email'], $handler['level'], $handler['bubble'], )); break; // Handlers using the constructor of AbstractHandler without adding their own arguments case 'test': case 'null': case 'debug': $definition->setArguments(array( $handler['level'], $handler['bubble'], )); break; default: throw new \InvalidArgumentException(sprintf('Invalid handler type "%s" given for handler "%s"', $handler['type'], $name)); } if (!empty($handler['formatter'])) { $definition->addMethodCall('setFormatter', array(new Reference($handler['formatter']))); } $container->setDefinition($handlerId, $definition); return $handlerId; }
/** * Resolves the definition. * * @param ContainerBuilder $container The ContainerBuilder * @param DefinitionDecorator $definition * * @return Definition * * @throws \RuntimeException When the definition is invalid */ private function resolveDefinition(ContainerBuilder $container, DefinitionDecorator $definition) { if (!$container->hasDefinition($parent = $definition->getParent())) { throw new RuntimeException(sprintf('The parent definition "%s" defined for definition "%s" does not exist.', $parent, $this->currentId)); } $parentDef = $container->getDefinition($parent); if ($parentDef instanceof DefinitionDecorator) { $id = $this->currentId; $this->currentId = $parent; $parentDef = $this->resolveDefinition($container, $parentDef); $container->setDefinition($parent, $parentDef); $this->currentId = $id; } $this->compiler->addLogMessage($this->formatter->formatResolveInheritance($this, $this->currentId, $parent)); $def = new Definition(); // merge in parent definition // purposely ignored attributes: scope, abstract, tags $def->setClass($parentDef->getClass()); $def->setArguments($parentDef->getArguments()); $def->setMethodCalls($parentDef->getMethodCalls()); $def->setProperties($parentDef->getProperties()); $def->setAutowiringTypes($parentDef->getAutowiringTypes()); if ($parentDef->getFactoryClass(false)) { $def->setFactoryClass($parentDef->getFactoryClass(false)); } if ($parentDef->getFactoryMethod(false)) { $def->setFactoryMethod($parentDef->getFactoryMethod(false)); } if ($parentDef->getFactoryService(false)) { $def->setFactoryService($parentDef->getFactoryService(false)); } if ($parentDef->isDeprecated()) { $def->setDeprecated(true, $parentDef->getDeprecationMessage('%service_id%')); } $def->setFactory($parentDef->getFactory()); $def->setConfigurator($parentDef->getConfigurator()); $def->setFile($parentDef->getFile()); $def->setPublic($parentDef->isPublic()); $def->setLazy($parentDef->isLazy()); // overwrite with values specified in the decorator $changes = $definition->getChanges(); if (isset($changes['class'])) { $def->setClass($definition->getClass()); } if (isset($changes['factory_class'])) { $def->setFactoryClass($definition->getFactoryClass(false)); } if (isset($changes['factory_method'])) { $def->setFactoryMethod($definition->getFactoryMethod(false)); } if (isset($changes['factory_service'])) { $def->setFactoryService($definition->getFactoryService(false)); } if (isset($changes['factory'])) { $def->setFactory($definition->getFactory()); } if (isset($changes['configurator'])) { $def->setConfigurator($definition->getConfigurator()); } if (isset($changes['file'])) { $def->setFile($definition->getFile()); } if (isset($changes['public'])) { $def->setPublic($definition->isPublic()); } if (isset($changes['lazy'])) { $def->setLazy($definition->isLazy()); } if (isset($changes['deprecated'])) { $def->setDeprecated($definition->isDeprecated(), $definition->getDeprecationMessage('%service_id%')); } if (isset($changes['decorated_service'])) { $decoratedService = $definition->getDecoratedService(); if (null === $decoratedService) { $def->setDecoratedService($decoratedService); } else { $def->setDecoratedService($decoratedService[0], $decoratedService[1], $decoratedService[2]); } } // merge arguments foreach ($definition->getArguments() as $k => $v) { if (is_numeric($k)) { $def->addArgument($v); continue; } if (0 !== strpos($k, 'index_')) { throw new RuntimeException(sprintf('Invalid argument key "%s" found.', $k)); } $index = (int) substr($k, strlen('index_')); $def->replaceArgument($index, $v); } // merge properties foreach ($definition->getProperties() as $k => $v) { $def->setProperty($k, $v); } // append method calls if (count($calls = $definition->getMethodCalls()) > 0) { $def->setMethodCalls(array_merge($def->getMethodCalls(), $calls)); } // merge autowiring types foreach ($definition->getAutowiringTypes() as $autowiringType) { $def->addAutowiringType($autowiringType); } // these attributes are always taken from the child $def->setAbstract($definition->isAbstract()); $def->setScope($definition->getScope(false), false); $def->setShared($definition->isShared()); $def->setTags($definition->getTags()); return $def; }
/** * {@inheritdoc} * * @api */ public function setFactoryService($service) { $this->changes['factory_service'] = true; return parent::setFactoryService($service); }
/** * Parses a definition. * * @param string $id * @param array $service * @param string $file * * @throws InvalidArgumentException When tags are invalid */ private function parseDefinition($id, $service, $file) { if (is_string($service) && 0 === strpos($service, '@')) { $this->container->setAlias($id, substr($service, 1)); return; } if (!is_array($service)) { throw new InvalidArgumentException(sprintf('A service definition must be an array or a string starting with "@" but %s found for service "%s" in %s. Check your YAML syntax.', gettype($service), $id, $file)); } if (isset($service['alias'])) { $public = !array_key_exists('public', $service) || (bool) $service['public']; $this->container->setAlias($id, new Alias($service['alias'], $public)); return; } if (isset($service['parent'])) { $definition = new DefinitionDecorator($service['parent']); } else { $definition = new Definition(); } if (isset($service['class'])) { $definition->setClass($service['class']); } if (isset($service['scope'])) { $definition->setScope($service['scope']); } if (isset($service['synthetic'])) { $definition->setSynthetic($service['synthetic']); } if (isset($service['synchronized'])) { $definition->setSynchronized($service['synchronized']); } if (isset($service['lazy'])) { $definition->setLazy($service['lazy']); } if (isset($service['public'])) { $definition->setPublic($service['public']); } if (isset($service['abstract'])) { $definition->setAbstract($service['abstract']); } if (isset($service['factory'])) { if (is_string($service['factory'])) { if (strpos($service['factory'], ':') !== false && strpos($service['factory'], '::') === false) { $parts = explode(':', $service['factory']); $definition->setFactory(array($this->resolveServices('@' . $parts[0]), $parts[1])); } else { $definition->setFactory($service['factory']); } } else { $definition->setFactory(array($this->resolveServices($service['factory'][0]), $service['factory'][1])); } } if (isset($service['factory_class'])) { $definition->setFactoryClass($service['factory_class']); } if (isset($service['factory_method'])) { $definition->setFactoryMethod($service['factory_method']); } if (isset($service['factory_service'])) { $definition->setFactoryService($service['factory_service']); } if (isset($service['file'])) { $definition->setFile($service['file']); } if (isset($service['arguments'])) { $definition->setArguments($this->resolveServices($service['arguments'])); } if (isset($service['properties'])) { $definition->setProperties($this->resolveServices($service['properties'])); } if (isset($service['configurator'])) { if (is_string($service['configurator'])) { $definition->setConfigurator($service['configurator']); } else { $definition->setConfigurator(array($this->resolveServices($service['configurator'][0]), $service['configurator'][1])); } } if (isset($service['calls'])) { if (!is_array($service['calls'])) { throw new InvalidArgumentException(sprintf('Parameter "calls" must be an array for service "%s" in %s. Check your YAML syntax.', $id, $file)); } foreach ($service['calls'] as $call) { $args = isset($call[1]) ? $this->resolveServices($call[1]) : array(); $definition->addMethodCall($call[0], $args); } } if (isset($service['tags'])) { if (!is_array($service['tags'])) { throw new InvalidArgumentException(sprintf('Parameter "tags" must be an array for service "%s" in %s. Check your YAML syntax.', $id, $file)); } foreach ($service['tags'] as $tag) { if (!is_array($tag)) { throw new InvalidArgumentException(sprintf('A "tags" entry must be an array for service "%s" in %s. Check your YAML syntax.', $id, $file)); } if (!isset($tag['name'])) { throw new InvalidArgumentException(sprintf('A "tags" entry is missing a "name" key for service "%s" in %s.', $id, $file)); } $name = $tag['name']; unset($tag['name']); foreach ($tag as $attribute => $value) { if (!is_scalar($value) && null !== $value) { throw new InvalidArgumentException(sprintf('A "tags" attribute must be of a scalar-type for service "%s", tag "%s", attribute "%s" in %s. Check your YAML syntax.', $id, $name, $attribute, $file)); } } $definition->addTag($name, $tag); } } if (isset($service['decorates'])) { $renameId = isset($service['decoration_inner_name']) ? $service['decoration_inner_name'] : null; $definition->setDecoratedService($service['decorates'], $renameId); } $this->container->setDefinition($id, $definition); }
/** * Parses a definition. * * @param string $id * @param array $service * @param string $file * * @throws InvalidArgumentException When tags are invalid */ private function parseDefinition($id, $service, $file) { if (is_string($service) && 0 === strpos($service, '@')) { $this->container->setAlias($id, substr($service, 1)); return; } elseif (isset($service['alias'])) { $public = !array_key_exists('public', $service) || (Boolean) $service['public']; $this->container->setAlias($id, new Alias($service['alias'], $public)); return; } if (isset($service['parent'])) { $definition = new DefinitionDecorator($service['parent']); } else { $definition = new Definition(); } if (isset($service['class'])) { $definition->setClass($service['class']); } if (isset($service['scope'])) { $definition->setScope($service['scope']); } if (isset($service['synthetic'])) { $definition->setSynthetic($service['synthetic']); } if (isset($service['public'])) { $definition->setPublic($service['public']); } if (isset($service['abstract'])) { $definition->setAbstract($service['abstract']); } if (isset($service['factory_class'])) { $definition->setFactoryClass($service['factory_class']); } if (isset($service['factory_method'])) { $definition->setFactoryMethod($service['factory_method']); } if (isset($service['factory_service'])) { $definition->setFactoryService($service['factory_service']); } if (isset($service['file'])) { $definition->setFile($service['file']); } if (isset($service['arguments'])) { $definition->setArguments($this->resolveServices($service['arguments'])); } if (isset($service['properties'])) { $definition->setProperties($this->resolveServices($service['properties'])); } if (isset($service['configurator'])) { if (is_string($service['configurator'])) { $definition->setConfigurator($service['configurator']); } else { $definition->setConfigurator(array($this->resolveServices($service['configurator'][0]), $service['configurator'][1])); } } if (isset($service['calls'])) { foreach ($service['calls'] as $call) { $args = isset($call[1]) ? $this->resolveServices($call[1]) : array(); $definition->addMethodCall($call[0], $args); } } if (isset($service['tags'])) { if (!is_array($service['tags'])) { throw new InvalidArgumentException(sprintf('Parameter "tags" must be an array for service "%s" in %s.', $id, $file)); } foreach ($service['tags'] as $tag) { if (!isset($tag['name'])) { throw new InvalidArgumentException(sprintf('A "tags" entry is missing a "name" key for service "%s" in %s.', $id, $file)); } $name = $tag['name']; unset($tag['name']); foreach ($tag as $attribute => $value) { if (!is_scalar($value)) { throw new InvalidArgumentException(sprintf('A "tags" attribute must be of a scalar-type for service "%s", tag "%s" in %s.', $id, $name, $file)); } } $definition->addTag($name, $tag); } } $this->container->setDefinition($id, $definition); }
/** * Resolves the definition * * @param string $id The definition identifier * @param DefinitionDecorator $definition * * @return Definition */ private function resolveDefinition($id, DefinitionDecorator $definition) { if (!$this->container->hasDefinition($parent = $definition->getParent())) { throw new RuntimeException(sprintf('The parent definition "%s" defined for definition "%s" does not exist.', $parent, $id)); } $parentDef = $this->container->getDefinition($parent); if ($parentDef instanceof DefinitionDecorator) { $parentDef = $this->resolveDefinition($parent, $parentDef); } $this->compiler->addLogMessage($this->formatter->formatResolveInheritance($this, $id, $parent)); $def = new Definition(); // merge in parent definition // purposely ignored attributes: scope, abstract, tags $def->setClass($parentDef->getClass()); $def->setArguments($parentDef->getArguments()); $def->setMethodCalls($parentDef->getMethodCalls()); $def->setProperties($parentDef->getProperties()); $def->setFactoryClass($parentDef->getFactoryClass()); $def->setFactoryMethod($parentDef->getFactoryMethod()); $def->setFactoryService($parentDef->getFactoryService()); $def->setConfigurator($parentDef->getConfigurator()); $def->setFile($parentDef->getFile()); $def->setPublic($parentDef->isPublic()); // overwrite with values specified in the decorator $changes = $definition->getChanges(); if (isset($changes['class'])) { $def->setClass($definition->getClass()); } if (isset($changes['factory_class'])) { $def->setFactoryClass($definition->getFactoryClass()); } if (isset($changes['factory_method'])) { $def->setFactoryMethod($definition->getFactoryMethod()); } if (isset($changes['factory_service'])) { $def->setFactoryService($definition->getFactoryService()); } if (isset($changes['configurator'])) { $def->setConfigurator($definition->getConfigurator()); } if (isset($changes['file'])) { $def->setFile($definition->getFile()); } if (isset($changes['public'])) { $def->setPublic($definition->isPublic()); } // merge arguments foreach ($definition->getArguments() as $k => $v) { if (is_numeric($k)) { $def->addArgument($v); continue; } if (0 !== strpos($k, 'index_')) { throw new RuntimeException(sprintf('Invalid argument key "%s" found.', $k)); } $index = (int) substr($k, strlen('index_')); $def->replaceArgument($index, $v); } // merge properties foreach ($definition->getProperties() as $k => $v) { $def->setProperty($k, $v); } // append method calls if (count($calls = $definition->getMethodCalls()) > 0) { $def->setMethodCalls(array_merge($def->getMethodCalls(), $calls)); } // these attributes are always taken from the child $def->setAbstract($definition->isAbstract()); $def->setScope($definition->getScope()); $def->setTags($definition->getTags()); // set new definition on container $this->container->setDefinition($id, $def); return $def; }
public function process(ContainerBuilder $container) { $ems = $container->getParameter('bruery.entity_audit.entity_managers'); $doctrineEms = $container->getParameter('doctrine.entity_managers'); $valid = false; foreach ($ems as $key => $value) { if (in_array($value, $doctrineEms)) { $valid = true; } else { $valid = false; break; } } if ($valid) { ##################################### ## Override Config ##################################### $definition = $container->getDefinition('simplethings_entityaudit.config'); $definition->setClass($container->getParameter('bruery.entity_audit.config.class')); ##################################### ## Override Audit Manager ##################################### $definition = $container->getDefinition('simplethings_entityaudit.manager'); $definition->setClass($container->getParameter('bruery.entity_audit.manager.class')); ##################################### ## Override Audit Reader ##################################### $definition = $container->getDefinition('simplethings_entityaudit.reader'); $definition->setClass($container->getParameter('bruery.entity_audit.reader.class')); $def = new Definition($container->getParameter('bruery.entity_audit.reader.class'), array(new Reference($ems['source']), new Reference($ems['audit']))); // if SimpleThingsEntityAudit upgrades to version Symfony 2.8+ if (method_exists($definition, 'setFactory') && ($definition->getFactoryMethod() === '' || $definition->getFactoryMethod() === null)) { $def->setFactory(array(new Reference('simplethings_entityaudit.manager'), 'createAuditReader')); } else { $def->setFactoryMethod('createAuditReader'); $def->setFactoryService('simplethings_entityaudit.manager'); } $container->setDefinition('simplethings_entityaudit.reader', $def); ##################################### ## Override Listeners ##################################### $definition = $container->getDefinition('simplethings_entityaudit.log_revisions_listener'); $definition->setClass($container->getParameter('bruery.entity_audit.listener.log_revisions.class')); $definition->addMethodCall('setAuditEm', array(new Reference($ems['audit']))); $definition->clearTag('doctrine.event_subscriber'); $definition->addTag('doctrine.event_subscriber', array('connection' => $container->getParameter('bruery.entity_audit.listener.log_revisions.connection'))); $definition = $container->getDefinition('simplethings_entityaudit.create_schema_listener'); $definition->setClass($container->getParameter('bruery.entity_audit.listener.create_schema.class')); $definition->clearTag('doctrine.event_subscriber'); $definition->addTag('doctrine.event_subscriber', array('connection' => $container->getParameter('bruery.entity_audit.listener.create_schema.connection'))); // $taggedServices = $container->findTaggedServiceIds('doctrine.event_subscriber'); // // // Replace tag attribute // foreach ($taggedServices as $id => $tags) { // if ($id === 'simplethings_entityaudit.log_revisions_listener') { // $definition = $container->getDefinition($id); // // } elseif ($id === 'simplethings_entityaudit.create_schema_listener') { // $definition = $container->getDefinition($id); // // } // } } }