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);
//
// }
// }
}
}
