public function load(array $configs, ContainerBuilder $container) { $loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config')); $loader->load('html_purifier.xml'); /* Prepend the default configuration. This cannot be defined within the * Configuration class, since the root node's children are array * prototypes. * * This cache path may be suppressed by either unsetting the "default" * configuration (relying on canBeUnset() on the prototype node) or * setting the "Cache.SerializerPath" option to null. */ array_unshift($configs, array('default' => array('Cache.SerializerPath' => '%kernel.cache_dir%/htmlpurifier'))); $configs = $this->processConfiguration(new Configuration(), $configs); $configs = array_map(array($this, 'resolveServices'), $configs); $paths = array(); foreach ($configs as $name => $config) { $configDefinition = new Definition('%exercise_html_purifier.config.class%'); $configDefinition->setFactoryClass('%exercise_html_purifier.config.class%'); if ('default' === $name) { $configDefinition->setFactoryMethod('create')->addArgument($config); } else { $configDefinition->setFactoryMethod('inherit')->addArgument(new Reference('exercise_html_purifier.config.default'))->addMethodCall('loadArray', array($config)); } $configId = 'exercise_html_purifier.config.' . $name; $container->setDefinition($configId, $configDefinition); $container->setDefinition('exercise_html_purifier.' . $name, new Definition('%exercise_html_purifier.class%', array(new Reference($configId)))); if (isset($config['Cache.SerializerPath'])) { $paths[] = $config['Cache.SerializerPath']; } } $container->setParameter('exercise_html_purifier.cache_warmer.serializer.paths', array_unique($paths)); }
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); } }
/** * {@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 loadDoctrine(ContainerBuilder $container, $config) { $this->loadConfiguration($container, $config); $definition = new Definition('Doctrine\\DBAL\\Connection', array(array('driver' => 'pdo_sqlite', 'memory' => true), new Reference('doctrine.configuration'))); $definition->setFactoryClass('Doctrine\\DBAL\\DriverManager'); $definition->setFactoryMethod('getConnection'); $container->setDefinition('doctrine.connection', $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); }
private function loadDoctrine(ContainerBuilder $container, $config) { $this->loadConfiguration($container, $config); $this->loadEventManager($container, $config); $definition = new Definition('Doctrine\\ORM\\EntityManager', array(array('driver' => 'pdo_sqlite', 'memory' => true), new Reference('doctrine.configuration'), new Reference('doctrine.event_manager'))); $definition->setFactoryClass('Doctrine\\ORM\\EntityManager'); $definition->setFactoryMethod('create'); $container->setDefinition('doctrine', $definition); }
/** * {@inheritDoc} */ public function process(ContainerBuilder $container) { $driver = $container->getDefinition('prezent_doctrine_translatable.driver_chain'); foreach ($container->getParameter('doctrine.entity_managers') as $name => $manager) { $adapter = new Definition('Metadata\\Driver\\DriverInterface', array(new Reference(sprintf('doctrine.orm.%s_metadata_driver', $name)))); $adapter->setFactoryClass('Prezent\\Doctrine\\Translatable\\Mapping\\Driver\\DoctrineAdapter'); $adapter->setFactoryMethod('fromMetadataDriver'); $driver->addMethodCall('addDriver', array($adapter)); } }
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} */ public function create(ContainerBuilder $container, $resolverName, array $config) { $awsS3ClientDefinition = new Definition('Aws\S3\S3Client'); $awsS3ClientDefinition->setFactoryClass('Aws\S3\S3Client'); $awsS3ClientDefinition->setFactoryMethod('factory'); $awsS3ClientDefinition->addArgument($config['client_config']); $awsS3ClientId = 'liip_imagine.cache.resolver.'.$resolverName.'.client'; $container->setDefinition($awsS3ClientId, $awsS3ClientDefinition); $resolverDefinition = new DefinitionDecorator('liip_imagine.cache.resolver.prototype.aws_s3'); $resolverDefinition->replaceArgument(0, new Reference($awsS3ClientId)); $resolverDefinition->replaceArgument(1, $config['bucket']); $resolverDefinition->replaceArgument(2, $config['acl']); $resolverDefinition->replaceArgument(3, array_replace($config['url_options'], $config['get_options'])); $resolverDefinition->replaceArgument(4, $config['put_options']); $resolverId = 'liip_imagine.cache.resolver.'.$resolverName; $container->setDefinition($resolverId, $resolverDefinition); if (isset($config['cache_prefix'])) { $resolverDefinition->addMethodCall('setCachePrefix', array($config['cache_prefix'])); } if ($config['proxies']) { $proxiedResolverId = 'liip_imagine.cache.resolver.'.$resolverName.'.proxied'; $container->setDefinition($proxiedResolverId, $resolverDefinition); $proxyResolverDefinition = new DefinitionDecorator('liip_imagine.cache.resolver.prototype.proxy'); $proxyResolverDefinition->replaceArgument(0, new Reference($proxiedResolverId)); $proxyResolverDefinition->replaceArgument(1, $config['proxies']); $container->setDefinition($resolverId, $proxyResolverDefinition); } if ($config['cache']) { $cachedResolverId = 'liip_imagine.cache.resolver.'.$resolverName.'.cached'; $container->setDefinition($cachedResolverId, $container->getDefinition($resolverId)); $cacheResolverDefinition = new DefinitionDecorator('liip_imagine.cache.resolver.prototype.cache'); $cacheResolverDefinition->replaceArgument(0, new Reference($config['cache'])); $cacheResolverDefinition->replaceArgument(1, new Reference($cachedResolverId)); $container->setDefinition($resolverId, $cacheResolverDefinition); } $container->getDefinition($resolverId)->addTag('liip_imagine.cache.resolver', array( 'resolver' => $resolverName, )); return $resolverId; }
/** * Creates a complex setting factory. * * The factory has a variable number of arguments. * Dynamic settings are added as tupples: first the argument without the leading and trailing $, so that it is not * transformed by the config resolver pass, then the argument as a string, so that it does get transformed. * * @param string $argumentValue The original argument ($var$/$another_var$) * @param array $dynamicSettings Array of dynamic settings in $argumentValue * * @return Definition */ private function createFactoryDefinition($argumentValue, $dynamicSettings) { $definition = new Definition('stdClass', array($argumentValue)); $definition->setFactoryClass('eZ\\Bundle\\EzPublishCoreBundle\\DependencyInjection\\Configuration\\ComplexSettings\\ComplexSettingValueFactory'); $definition->setFactoryMethod('getArgumentValue'); foreach ($dynamicSettings as $dynamicSetting) { // Trim the '$' so that the dynamic setting doesn't get transformed $definition->addArgument(trim($dynamicSetting, '$')); // This one will be transformed $definition->addArgument($dynamicSetting); } 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 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))); }
public function load(array $configs, ContainerBuilder $container) { $configuration = $this->getConfiguration($configs, $container); $config = $this->processConfiguration($configuration, $configs); $loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config')); $loader->load('metrics.xml'); $registry = $container->getDefinition('beberlei_metrics.registry'); $registry->addMethodCall('setDefaultName', array($config['default'])); foreach ($config['collectors'] as $name => $collector) { $def = new Definition('Beberlei\\Metrics\\Collector\\Collector'); $def->setFactoryMethod('create'); $def->setFactoryClass('%beberlei_metrics.factory.class%'); $def->setArguments(array($collector['type'], $collector)); $container->setDefinition('beberlei_metrics.collector.' . $name, $def); $registry->addMethodCall('set', array($name, new Reference('beberlei_metrics.collector.' . $name))); } }
/** * {@inheritDoc} */ protected function addApis(Definition $paymentDefinition, ContainerBuilder $container, $contextName, array $config) { $internalConnectorDefinition = new Definition('Klarna_Checkout_ConnectorInterface'); $internalConnectorDefinition->setFactoryClass('Klarna_Checkout_Connector'); $internalConnectorDefinition->setFactoryMethod('create'); $internalConnectorDefinition->addArgument($config['secret']); $internalConnectorId = 'payum.context.' . $contextName . '.internal_connector'; $container->setDefinition($internalConnectorId, $internalConnectorDefinition); $connectorDefinition = new Definition('%payum.klarna.checkout.connector.class%'); $connectorDefinition->addArgument(new Reference($internalConnectorId)); $connectorDefinition->addArgument($config['merchant_id']); $connectorDefinition->addArgument($config['sandbox'] ? Constants::BASE_URI_SANDBOX : Constants::BASE_URI_LIVE); $connectorDefinition->addArgument(Constants::CONTENT_TYPE_V2_PLUS_JSON); $connectorId = 'payum.context.' . $contextName . '.connector'; $container->setDefinition($connectorId, $connectorDefinition); $paymentDefinition->addMethodCall('addApi', array(new Reference($connectorId))); }
/** * {@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'); }
/** * {@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')); $loader->load('services.xml'); $container->setParameter('lexik_monolog_browser.base_layout', $config['base_layout']); $container->setParameter('lexik_monolog_browser.logs_per_page', $config['logs_per_page']); $container->setParameter('lexik_monolog_browser.doctrine.table_name', $config['doctrine']['table_name']); if (isset($config['doctrine']['connection_name'])) { $container->setAlias('lexik_monolog_browser.doctrine_dbal.connection', sprintf('doctrine.dbal.%s_connection', $config['doctrine']['connection_name'])); } if (isset($config['doctrine']['connection'])) { $connectionDefinition = new Definition('Doctrine\\DBAL\\Connection', array($config['doctrine']['connection'])); $connectionDefinition->setFactoryClass('Doctrine\\DBAL\\DriverManager'); $connectionDefinition->setFactoryMethod('getConnection'); $container->setDefinition('lexik_monolog_browser.doctrine_dbal.connection', $connectionDefinition); } }
public function navLoad($config, ContainerBuilder $container) { $loader = new XmlFileLoader($container, __DIR__ . '/../Resources/config'); $loader->load('navigation.xml'); $configDir = $container->getParameter('kernel.root_dir') . '/config/'; foreach ($config as $containerName => $yamlConfigFile) { if (!is_string($yamlConfigFile)) { $yamlConfigFile = $containerName . '.yml'; } $yamlConfigFile = "nav_" . $yamlConfigFile; $yamlConfigFile = $configDir . $yamlConfigFile; $def = new Definition("Bundle\\ZendNavigationBundle\\Navigation"); $def->setFactoryMethod('factory'); $def->addArgument(new Reference('router')); $def->addArgument(new Reference('request')); $def->addArgument($yamlConfigFile); $container->setDefinition('zend.navigation.' . $containerName, $def); } }
public function load(array $configs, ContainerBuilder $container) { $loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config')); $loader->load('compat.xml'); foreach ($configs as $config) { if (isset($config['default_layout_resource'])) { $container->setParameter('whitewashing.zfmvccompat.default_layout_resource', $config['default_layout_resource']); } if (isset($config['catchall_bundles'])) { $container->setParameter('whitewashing.zfmvccompat.catchall_bundles', $config['catchall_bundles']); } if (isset($config['db_conn'])) { $def = new Definition('Zend_Db_Adapter_Abstract'); $def->setFactoryClass('Zend_Db'); $def->setFactoryMethod('factory'); $def->setArguments(array($config['db_conn']['adapter'], $config['db_conn']['params'])); $container->setDefinition('whitewashing.zfmvcompat.db', $def); } } }
/** * 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 load(array $configs, ContainerBuilder $container) { $configuration = new Configuration(); $config = $this->processConfiguration($configuration, $configs); if (!isset($config['table'])) { return; } $loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config')); $loader->load('services.xml'); $aws_config = array(); if (isset($config['aws'])) { $aws_config = $config['aws']; } if (!isset($config['dynamo_client_id'])) { $dynamoClass = $container->getParameter("dynamo_session_client.class"); $def = new Definition($dynamoClass); $def->setFactoryClass($dynamoClass); $def->setFactoryMethod("factory"); $def->setArguments(array($aws_config)); $container->setDefinition("dynamo_session_client", $def); $config['dynamo_client_id'] = "dynamo_session_client"; } else { $container->removeDefinition("dynamo_session_client"); $container->setAlias("dynamo_session_client", $config['dynamo_client_id']); } $container->setParameter("dynamo_session_table", $config['table']); $container->setParameter("dynamo_session_read_capacity", $config['read_capacity']); $container->setParameter("dynamo_session_write_capacity", $config['write_capacity']); $dynamo_config = array('table_name' => $config['table'], 'locking_strategy' => $config['locking_strategy']); foreach (array('automatic_gc', 'gc_batch_size', 'session_lifetime') as $key) { if (isset($config[$key])) { $dynamo_config[$key] = $config[$key]; } } $handler = $container->getDefinition("dynamo_session_handler"); $handler->setArguments(array(new Reference("dynamo_session_client"), $dynamo_config)); }
/** * {@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; }