/** * @expectedException \OutOfBoundsException */ public function testGetArgumentShouldCheckBounds() { $def = new DefinitionDecorator('foo'); $def->setArguments(array(0 => 'foo')); $def->replaceArgument(0, 'foo'); $def->getArgument(1); }
public function process(ContainerBuilder $container) { if (!($container->hasDefinition('fragment.listener') && $container->hasDefinition('ezpublish.decorated_fragment_renderer'))) { return null; } $fragmentListenerDef = $container->findDefinition('fragment.listener'); $fragmentListenerDef->setFactoryService('ezpublish.fragment_listener.factory')->setFactoryMethod('buildFragmentListener')->addArgument('%fragment.listener.class%'); // Looping over all fragment renderers to decorate them // This is to make sure they are siteaccess aware (siteaccess is serialized in rendered path). foreach ($container->findTaggedServiceIds('kernel.fragment_renderer') as $id => $attributes) { $renamedId = "{$id}.inner"; $definition = $container->getDefinition($id); $public = $definition->isPublic(); $tags = $definition->getTags(); $definition->setPublic(false); $container->setDefinition($renamedId, $definition); $decoratedDef = new DefinitionDecorator('ezpublish.decorated_fragment_renderer'); $decoratedDef->setArguments(array(new Reference($renamedId))); $decoratedDef->setPublic($public); $decoratedDef->setTags($tags); // Special treatment for inline fragment renderer, to fit ESI renderer constructor type hinting (forced to InlineFragmentRenderer) if ($id === 'fragment.renderer.inline') { $decoratedDef->setClass($container->getParameter('ezpublish.decorated_fragment_renderer.inline.class')); } $container->setDefinition($id, $decoratedDef); } }
/** * @param array $config * @param ContainerBuilder $container */ private function loadArrayFormType(ContainerBuilder $container, array $config) { $serviceId = 'jd_form.form_type.array'; $types = ['hidden', 'text']; foreach ($types as $type) { $typeDef = new DefinitionDecorator($serviceId); $typeDef->setArguments([$type, $config['delimiter']])->addTag('form.type', ['alias' => 'array_' . $type]); $container->setDefinition($serviceId . '_' . $type, $typeDef); } }
private function configureConnectionClient(ContainerBuilder $builder, $connectionName, array $connectionConfig, $profiling) { $connectionDef = new DefinitionDecorator('kassko_cassandra.connection.prototype'); $connectionDef->addTag('kassko_cassandra.connection'); //logger Cql creation. $loggerCqlServiceName = $this->computeLoggerCqlServiceName($connectionName); $loggerCqlServiceDef = new DefinitionDecorator('kassko_cassandra.logger_cql.prototype'); if (isset($connectionConfig['logger_service'])) { $loggerCqlServiceDef->replaceArgument(0, new Reference($connectionConfig['logger_service'])); } $builder->setDefinition($loggerCqlServiceName, $loggerCqlServiceDef); //loggerChain creation. $loggerChainServiceName = $this->computeLoggerChainServiceName($connectionName); $loggerChainDef = new DefinitionDecorator('kassko_cassandra.logger_chain.prototype'); $builder->setDefinition($loggerChainServiceName, $loggerChainDef); $loggerChainDef->addMethodCall('addLogger', [new Reference($loggerCqlServiceName)]); if ($profiling) { $loggerProfilerServiceName = $this->computeLoggerProfilerServiceName($connectionName); $builder->setDefinition($loggerProfilerServiceName, new DefinitionDecorator('kassko_cassandra.logger_profiler.prototype')); $loggerChainDef->addMethodCall('addLogger', [new Reference($loggerProfilerServiceName)]); $queryStatsManagerDef = $builder->getDefinition('kassko_cassandra.query_stats.manager'); $queryStatsManagerDef->addMethodCall('addLogger', [$connectionName, new Reference($loggerProfilerServiceName)]); } if (isset($connectionConfig['event_dispatcher_service'])) { $connectionDef->addMethodCall('setEventDispatcher', [new Reference($connectionConfig['event_dispatcher_service'])]); } $connectionDef->addMethodCall('setLogger', [new Reference($loggerChainServiceName)]); $connectionDef->addMethodCall('useKeyspace', [$connectionConfig['keyspace']]); list($dsn, $username, $password) = $this->resolveConnectionParam($connectionConfig); if (null === $username xor null === $password) { throw new \LogicException(sprintf('username and password should be provided both or neither for keyspace "%s".', $connectionConfig['keyspace'])); } if (null !== $username) { $connectionDef->setArguments([$dsn, $username, $password]); } else { $connectionDef->setArguments([$dsn]); } $serviceName = $this->computeServiceName($connectionName); $builder->setDefinition($serviceName, $connectionDef); if (isset($connectionConfig['alias'])) { $builder->setAlias($connectionConfig['alias'], $serviceName); } }
/** * Converts class hierarchy metadata to definition instances. * * @param ClassHierarchyMetadata $metadata * @return array an array of Definition instances */ public function convert(ClassHierarchyMetadata $metadata) { static $count = 0; $definitions = array(); $previous = null; foreach ($metadata->classMetadata as $classMetadata) { if (null === $previous && null === $classMetadata->parent) { $definition = new Definition(); } else { $definition = new DefinitionDecorator($classMetadata->parent ?: $previous->id); } $definition->setClass($classMetadata->name); if (null !== $classMetadata->scope) { $definition->setScope($classMetadata->scope); } if (null !== $classMetadata->public) { $definition->setPublic($classMetadata->public); } if (null !== $classMetadata->abstract) { $definition->setAbstract($classMetadata->abstract); } if (null !== $classMetadata->lazy) { $definition->setLazy($classMetadata->lazy); } if (null !== $classMetadata->arguments) { $definition->setArguments($classMetadata->arguments); } $definition->setMethodCalls($classMetadata->methodCalls); $definition->setTags($classMetadata->tags); $definition->setProperties($classMetadata->properties); if (null !== $classMetadata->decorates) { if (!method_exists($definition, 'setDecoratedService')) { throw new InvalidAnnotationException(sprintf("decorations require symfony >=2.8 on class %s", $classMetadata->name)); } $definition->setDecoratedService($classMetadata->decorates, $classMetadata->decoration_inner_name); } if (null !== $classMetadata->deprecated && method_exists($definition, 'setDeprecated')) { $definition->setDeprecated(true, $classMetadata->deprecated); } if (null === $classMetadata->id) { $classMetadata->id = '_jms_di_extra.unnamed.service_' . $count++; } if (0 !== count($classMetadata->initMethods)) { foreach ($classMetadata->initMethods as $initMethod) { $definition->addMethodCall($initMethod); } } elseif (null !== $classMetadata->initMethod) { @trigger_error('ClassMetadata::$initMethod is deprecated since version 1.7 and will be removed in 2.0. Use ClassMetadata::$initMethods instead.', E_USER_DEPRECATED); $definition->addMethodCall($classMetadata->initMethod); } $definitions[$classMetadata->id] = $definition; $previous = $classMetadata; } return $definitions; }
public function definitionProvider() { $definitionWithNoArguments = new Definition(); $definitionWithArguments = new Definition(); $rightValue = 'the right value'; $wrongValue = 'the wrong value'; $arguments = array(0 => 'first argument', 1 => $rightValue); $definitionWithArguments->setArguments($arguments); $decoratedDefinitionWithArguments = new DefinitionDecorator('parent_service_id'); $decoratedDefinitionWithArguments->setArguments(array(0 => 'first argument', 1 => $wrongValue)); $decoratedDefinitionWithArguments->replaceArgument(1, $rightValue); return array(array($definitionWithNoArguments, 1, $rightValue, false), array($definitionWithNoArguments, 1, $wrongValue, false), array($definitionWithArguments, 1, $rightValue, true), array($decoratedDefinitionWithArguments, 1, $rightValue, true)); }
public function load(array $configs, ContainerBuilder $container) { $configuration = new Configuration(); $config = $this->processConfiguration($configuration, $configs); $loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config')); $loader->load('services.yml'); if (empty($config['default_connection'])) { $keys = array_keys($config['connections']); $config['default_connection'] = reset($keys); } $connections = []; foreach ($config['connections'] as $name => $connectionOptions) { $connections[$name] = sprintf('sirian.sphinx.%s_connection', $name); $connectionDefinition = new DefinitionDecorator('sirian.sphinx.connection'); $connectionDefinition->setArguments([$connectionOptions]); $container->setDefinition($connections[$name], $connectionDefinition); } $container->setParameter('sirian.sphinx.default_connection', $config['default_connection']); $container->setParameter('sirian.sphinx.connections', $connections); }
/** * Converts class hierarchy metadata to definition instances. * * @param ClassHierarchyMetadata $metadata * @return array an array of Definition instances */ public function convert(ClassHierarchyMetadata $metadata) { static $count = 0; $definitions = array(); $previous = null; foreach ($metadata->classMetadata as $classMetadata) { if (null === $previous && null === $classMetadata->parent) { $definition = new Definition(); } else { $definition = new DefinitionDecorator($classMetadata->parent ?: $previous->id); } $definition->setClass($classMetadata->name); if (null !== $classMetadata->scope) { $definition->setScope($classMetadata->scope); } if (null !== $classMetadata->public) { $definition->setPublic($classMetadata->public); } if (null !== $classMetadata->abstract) { $definition->setAbstract($classMetadata->abstract); } if (null !== $classMetadata->arguments) { $definition->setArguments($classMetadata->arguments); } $definition->setMethodCalls($classMetadata->methodCalls); $definition->setTags($classMetadata->tags); $definition->setProperties($classMetadata->properties); if (null === $classMetadata->id) { $classMetadata->id = '_jms_di_extra.unnamed.service_' . $count++; } if ($classMetadata->initMethod) { if (!method_exists($definition, 'setInitMethod')) { throw new \RuntimeException(sprintf('@AfterSetup is not available on your Symfony version.')); } $definition->setInitMethod($classMetadata->initMethod); } $definitions[$classMetadata->id] = $definition; $previous = $classMetadata; } return $definitions; }
/** * @throws \LogicException */ public function generate() { $definition = new DefinitionDecorator('phpmentors_pageflower.reflection_conversational_controller'); $definition->setArguments(array($this->controllerClass->getName())); foreach ($this->controllerClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) { /* @var $method \ReflectionMethod */ if ($method->getDeclaringClass()->getName() == $this->controllerClass->getName()) { foreach ($this->reader->getMethodAnnotations($method) as $annotation) { if ($annotation instanceof Init) { $definition->addMethodCall('addInitMethod', array($method->getName())); } elseif ($annotation instanceof Accept) { if ($annotation->value === null || is_string($annotation->value) && strlen($annotation->value) == 0) { throw new \LogicException(sprintf('The value for annotation "%s" cannot be empty.', get_class($annotation))); } foreach ((array) $annotation->value as $accept) { if ($accept === null || strlen($accept) == 0) { throw new \LogicException(sprintf('The value for annotation "%s" cannot be empty.', get_class($annotation))); } if (!in_array($accept, $this->states)) { throw new \LogicException(sprintf('The value for annotation "%s" must be a one of [ %s ], "%s" is specified.', 'PHPMentors\\PageflowerBundle\\Annotation\\Accept', implode(', ', $this->states), $accept)); } $definition->addMethodCall('addAcceptableState', array($method->getName(), $accept)); } } } } } foreach ($this->controllerClass->getProperties() as $property) { /* @var $property \ReflectionProperty */ if ($property->getDeclaringClass()->getName() == $this->controllerClass->getName() && !$property->isStatic()) { foreach ($this->reader->getPropertyAnnotations($property) as $annotation) { $definition->addMethodCall('addStatefulProperty', array($property->getName())); } } } $reflectionConversationalControllerServiceId = 'phpmentors_pageflower.reflection_conversational_controller.' . $this->controllerServiceId; $this->container->setDefinition($reflectionConversationalControllerServiceId, $definition); $this->container->getDefinition('phpmentors_pageflower.reflection_conversational_controller_repository')->addMethodCall('add', array(new Reference($reflectionConversationalControllerServiceId))); }
/** * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container * @param string $providerKey * @param array config * @param string $facebookAdapterId * @return string */ public function createListener(ContainerBuilder $container, $providerKey, array $config, $facebookAdapterId) { $listenerId = FacebookAuthenticationExtension::CONTAINER_SERVICE_ID_SECURITY_FIREWALL_LISTENER; $listener = new DefinitionDecorator($listenerId); $listener->setArguments([new Reference('security.context'), new Reference('security.authentication.manager'), new Reference('security.authentication.session_strategy'), new Reference('security.http_utils'), $providerKey, new Reference($config[self::CONFIG_NODE_NAME_AUTHENTICATION_SUCCESS_HANDLER]), new Reference($config[self::CONFIG_NODE_NAME_AUTHENTICATION_FAILURE_HANDLER]), $config, $container->has('logger') ? new Reference('logger') : null, new Reference('event_dispatcher')]); $listener->addMethodCall('setFacebookAdapter', [new Reference($facebookAdapterId)]); $listenerId = $this->namespaceServiceId($listenerId, $providerKey); $container->setDefinition($listenerId, $listener); return $listenerId; }
/** * Configures the basic auth subscriber definition. * * @param \Symfony\Component\DependencyInjection\Definition $subscriber The subscriber. * @param array $basicAuth The basic auth. * @param string $adapterName The adapter name. * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container The container. */ private function configureBasicAuthSubscriberDefinition(Definition $subscriber, array $basicAuth, $adapterName, ContainerBuilder $container) { $model = new DefinitionDecorator(self::createServiceName('subscriber.basic_auth.model')); $model->setArguments(array($basicAuth['username'], $basicAuth['password'])); if (isset($basicAuth['matcher'])) { $model->addArgument($basicAuth['matcher']); } $container->setDefinition($service = self::createServiceName($adapterName . '.basic_auth.model'), $model); $subscriber->setArguments(array(new Reference($service))); }
/** * @throws \LogicException */ public function generate() { $pageflowAnnotation = $this->reader->getClassAnnotation($this->controllerClass, 'PHPMentors\\PageflowerBundle\\Annotation\\Pageflow'); if ($pageflowAnnotation === null) { throw new \LogicException(sprintf('Annotation "%s" is not found in class "%s".', 'PHPMentors\\PageflowerBundle\\Annotation\\Pageflow', $this->controllerClass->getName())); } $pageflowBuilderDefinition = new DefinitionDecorator('phpmentors_pageflower.pageflow_builder'); $pageflowBuilderDefinition->setArguments(array($this->controllerServiceId)); $statesFound = false; $transitionsFound = false; foreach ($pageflowAnnotation->value as $annotation) { if ($annotation instanceof States) { if ($statesFound) { throw new \LogicException(sprintf('Annotation "%s" must be specified only once.', get_class($annotation))); } $statesFound = true; foreach ($annotation->value as $state) { if ($state instanceof AnnotationInterface) { if ($state->value === null || strlen($state->value) == 0) { throw new \LogicException(sprintf('The value for annotation "%s" cannot be empty.', get_class($state))); } if ($state instanceof Start) { $pageflowBuilderDefinition->addMethodCall('addState', array($state->value)); $pageflowBuilderDefinition->addMethodCall('setStartState', array($state->value)); $this->states[] = $state->value; } elseif ($state instanceof End) { $pageflowBuilderDefinition->addMethodCall('addState', array($state->value)); $pageflowBuilderDefinition->addMethodCall('setEndState', array($state->value, StateInterface::STATE_FINAL)); $this->states[] = $state->value; } else { throw new \LogicException(sprintf('State "%s" must be encapsulated with one of [ %s ], "%s" is specified.', $state->value, implode(', ', array('PHPMentors\\PageflowerBundle\\Annotation\\Start', 'PHPMentors\\PageflowerBundle\\Annotation\\End')), get_class($state))); } } else { if ($state === null || strlen($state) == 0) { throw new \LogicException(sprintf('The value for annotation "%s" cannot be empty.', get_class($annotation))); } $pageflowBuilderDefinition->addMethodCall('addState', array($state)); $this->states[] = $state; } } } elseif ($annotation instanceof Transitions) { if ($transitionsFound) { throw new \LogicException(sprintf('Annotation "%s" must be specified only once.', get_class($annotation))); } $transitionsFound = true; foreach ($annotation->value as $transition) { if (is_array($transition) && count($transition) == 2 && is_string($transition[0]) && is_string($transition[1])) { foreach (array($transition[0], $transition[1]) as $state) { if ($state === null || strlen($state) == 0) { throw new \LogicException(sprintf('The value for annotation "%s" cannot be empty.', get_class($annotation))); } if (!in_array($state, $this->states)) { throw new \LogicException(sprintf('The value for annotation "%s" must be one of [ %s ], "%s" is specified.', get_class($annotation), implode(', ', $this->states), $state)); } } $pageflowBuilderDefinition->addMethodCall('addTransition', array($transition[0], $transition[1], $transition[1])); } else { throw new \LogicException(sprintf('The value for annotation "%s" must be string array, "%s" is specified.', get_class($annotation), var_export($transition, true))); } } } else { throw new \LogicException(sprintf('The value for annotation "%s" must be one of [ %s ], "%s" is specified.', get_class($pageflowAnnotation), implode(', ', array('"PHPMentors\\PageflowerBundle\\Annotation\\States"', '"PHPMentors\\PageflowerBundle\\Annotation\\Transitions"')), is_object($annotation) ? get_class($annotation) : $annotation)); } } $pageflowBuilderServiceId = 'phpmentors_pageflower.pageflow_builder.' . $this->controllerServiceId; $this->container->setDefinition($pageflowBuilderServiceId, $pageflowBuilderDefinition); $pageflowDefinition = new DefinitionDecorator('phpmentors_pageflower.pageflow'); $pageflowDefinition->setFactoryService($pageflowBuilderServiceId); $pageflowServiceId = 'phpmentors_pageflower.pageflow.' . $this->controllerServiceId; $this->container->setDefinition($pageflowServiceId, $pageflowDefinition); $this->container->getDefinition('phpmentors_pageflower.pageflow_repository')->addMethodCall('add', array(new Reference($pageflowServiceId))); $this->container->addClassResource($this->controllerClass); }
private function createCollectionDefinition($model, $type, $options, ContainerBuilder $container) { $collection = new DefinitionDecorator('lyra_admin.action_collection'); $collection->setArguments(array($options))->setPublic(false); $container->setDefinition(sprintf('lyra_admin.%s.%s.collection', $model, $type), $collection); }
/** * Configure a mapping from a filesystem path to a RequireJS namespace. * @param string $location * @param string $path * @param ContainerBuilder $container * @param boolean $generateAssets */ protected function addNamespaceMapping($location, $path, ContainerBuilder $container, $generateAssets = true) { $location = $this->getRealPath($location, $container); // Register the namespace with the configuration $mapping = $container->getDefinition('hearsay_require_js.namespace_mapping'); $mapping->addMethodCall('registerNamespace', array($path, $location)); $config = $container->getDefinition('hearsay_require_js.configuration_builder'); $config->addMethodCall('setPath', array($path, $location)); if ($path && $container->hasDefinition('hearsay_require_js.optimizer_filter')) { $filter = $container->getDefinition('hearsay_require_js.optimizer_filter'); $filter->addMethodCall('addPath', array($path, preg_replace('~\\.js$~', '', $location))); } if ($generateAssets) { $resource = new DefinitionDecorator('hearsay_require_js.filenames_resource'); $resource->setArguments(array($location)); $resource->addTag('assetic.formula_resource', array('loader' => 'require_js')); $container->addDefinitions(array('hearsay_require_js.filenames_resource.' . md5($location) => $resource)); } }