Sets the arguments to pass to the service constructor/factory method.
|
public setArguments ( array $arguments ) : |
||
| $arguments | array | An array of arguments |
| return | The current instance | |
/**
* {@inheritdoc}
*/
public function createDefinition(ContainerBuilder $container, array $config)
{
$definition = new Definition('Jose\\Object\\JWK');
$definition->setFactory([new Reference('jose.factory.jwk'), 'createFromKeySet']);
$definition->setArguments([new Reference($config['key_set']), $config['index']]);
return $definition;
}
/**
* {@inheritdoc}
*/
public function createDefinition(ContainerBuilder $container, array $config)
{
$definition = new Definition('Jose\\Object\\JWK');
$definition->setFactory([new Reference('jose.factory.jwk'), 'createFromKeyFile']);
$definition->setArguments([$config['path'], $config['password'], $config['additional_values']]);
return $definition;
}
/**
* {@inheritdoc}
*/
public function createDefinition(ContainerBuilder $container, array $config)
{
$definition = new Definition('Jose\\Object\\JWKSet');
$definition->setFactory([new Reference('jose.factory.jwk'), 'createFromValues']);
$definition->setArguments([json_decode($config['value'], true)]);
return $definition;
}
/**
* @param string $class
* @param Definition $definition
* @param string[] $classes
* @param string $id
* @param ContainerBuilder $container
*/
private function autowireConstructor($class, Definition $definition, array $classes, $id, ContainerBuilder $container)
{
$reflection = new ReflectionClass($class);
$constructor = $reflection->getConstructor();
// service not created by factory with public constructor with not fully configured arguments
if ($constructor !== NULL && $constructor->isPublic() && $definition->getFactoryMethod() === NULL) {
$autowiredArgs = $this->autowireMethod($constructor, $definition->getArguments(), $classes, $id, $container);
if ($definition instanceof DefinitionDecorator && $definition->getParent() !== NULL) {
$parentDef = $container->getDefinition($definition->getParent());
$parentDefArgsCount = count($parentDef->getArguments());
$argsToReplace = array();
foreach ($autowiredArgs as $i => $arg) {
if ($i < $parentDefArgsCount) {
$argsToReplace[$i] = $arg;
unset($autowiredArgs[$i]);
}
}
$definition->setArguments($autowiredArgs);
foreach ($argsToReplace as $i => $arg) {
$definition->replaceArgument($i, $arg);
}
} else {
$definition->setArguments($autowiredArgs);
}
}
}
function it_processes_the_configuration_and_registers_services_per_subject(ContainerBuilder $container)
{
$container->hasParameter('sylius.translation.mapping')->willReturn(false);
$container->hasParameter('sylius.translation.default.mapping')->willReturn(true);
$container->getParameter('sylius.translation.default.mapping')->willReturn(array(array('default_mapping' => array('translatable' => array('field' => 'translations', 'currentLocale' => 'currentLocale', 'fallbackLocale' => 'fallbackLocale'), 'translation' => array('field' => 'translatable', 'locale' => 'locale')))));
$attributeFormType = new Definition('Some\\App\\Product\\Form\\AttributeType');
$attributeFormType->setArguments(array('Some\\App\\Product\\Entity\\Attribute', '%sylius.validation_group.product_attribute%', 'product'));
$attributeFormType->addTag('form.type', array('alias' => 'sylius_product_attribute'));
$container->setDefinition('sylius.form.type.product_attribute', $attributeFormType)->shouldBeCalled();
$attributeTranslationFormType = new Definition('Some\\App\\Product\\Form\\AttributeTranslationType');
$attributeTranslationFormType->setArguments(array('Some\\App\\Product\\Entity\\AttributeTranslation', '%sylius.validation_group.product_attribute_translation%', 'product'));
$attributeTranslationFormType->addTag('form.type', array('alias' => 'sylius_product_attribute_translation'));
$container->setDefinition('sylius.form.type.product_attribute_translation', $attributeTranslationFormType)->shouldBeCalled();
$choiceTypeClasses = array(SyliusResourceBundle::DRIVER_DOCTRINE_ORM => 'Sylius\\Bundle\\AttributeBundle\\Form\\Type\\AttributeEntityChoiceType');
$attributeChoiceFormType = new Definition($choiceTypeClasses[SyliusResourceBundle::DRIVER_DOCTRINE_ORM]);
$attributeChoiceFormType->setArguments(array('product', 'Some\\App\\Product\\Entity\\Attribute'));
$attributeChoiceFormType->addTag('form.type', array('alias' => 'sylius_product_attribute_choice'));
$container->setDefinition('sylius.form.type.product_attribute_choice', $attributeChoiceFormType)->shouldBeCalled();
$attributeValueFormType = new Definition('Some\\App\\Product\\Form\\AttributeValueType');
$attributeValueFormType->setArguments(array('Some\\App\\Product\\Entity\\AttributeValue', '%sylius.validation_group.product_attribute_value%', 'product'));
$attributeValueFormType->addTag('form.type', array('alias' => 'sylius_product_attribute_value'));
$container->setDefinition('sylius.form.type.product_attribute_value', $attributeValueFormType)->shouldBeCalled();
$subjects = array('product' => array('subject' => 'Some\\App\\Product\\Entity\\Product', 'attribute' => array('model' => 'Some\\App\\Product\\Entity\\Attribute', 'form' => 'Some\\App\\Product\\Form\\AttributeType', 'translation' => array('model' => 'Some\\App\\Product\\Entity\\AttributeTranslation', 'form' => array('default' => 'Some\\App\\Product\\Form\\AttributeTranslationType'))), 'attribute_value' => array('model' => 'Some\\App\\Product\\Entity\\AttributeValue', 'form' => 'Some\\App\\Product\\Form\\AttributeValueType')));
$container->setParameter('sylius.attribute.subjects', $subjects)->shouldBeCalled();
$userConfig = array('driver' => SyliusResourceBundle::DRIVER_DOCTRINE_ORM, 'classes' => array('product' => array('subject' => 'Some\\App\\Product\\Entity\\Product', 'attribute' => array('model' => 'Some\\App\\Product\\Entity\\Attribute', 'form' => 'Some\\App\\Product\\Form\\AttributeType', 'translation' => array('model' => 'Some\\App\\Product\\Entity\\AttributeTranslation', 'form' => array('default' => 'Some\\App\\Product\\Form\\AttributeTranslationType'))), 'attribute_value' => array('model' => 'Some\\App\\Product\\Entity\\AttributeValue', 'form' => 'Some\\App\\Product\\Form\\AttributeValueType'))));
$processedConfig = array('driver' => SyliusResourceBundle::DRIVER_DOCTRINE_ORM, 'classes' => array('product_attribute' => array('model' => 'Some\\App\\Product\\Entity\\Attribute', 'form' => 'Some\\App\\Product\\Form\\AttributeType', 'translation' => array('model' => 'Some\\App\\Product\\Entity\\AttributeTranslation', 'form' => array('default' => 'Some\\App\\Product\\Form\\AttributeTranslationType'))), 'product_attribute_value' => array('model' => 'Some\\App\\Product\\Entity\\AttributeValue', 'form' => 'Some\\App\\Product\\Form\\AttributeValueType')), 'validation_groups' => array('product_attribute' => array('sylius'), 'product_attribute_translation' => array('sylius'), 'product_attribute_value' => array('sylius')));
$this->process($userConfig, $container)->shouldReturn($processedConfig);
}
/**
* {@inheritdoc}
*/
public function load(array $config, ContainerBuilder $container)
{
$config = $this->processConfiguration(new Configuration(), $config);
$loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load(sprintf('driver/%s.xml', $config['driver']));
$this->registerResources('sylius', $config['driver'], $config['resources'], $container);
$configFiles = ['services.xml'];
foreach ($configFiles as $configFile) {
$loader->load($configFile);
}
$factoryDefinition = new Definition(Factory::class);
$factoryDefinition->setArguments([new Parameter('sylius.model.taxonomy.class')]);
$translatableFactoryDefinition = $container->getDefinition('sylius.factory.taxonomy');
$taxonomyFactoryClass = $translatableFactoryDefinition->getClass();
$translatableFactoryDefinition->setClass(TranslatableFactory::class);
$translatableFactoryDefinition->setArguments([$factoryDefinition, new Reference('sylius.translation.locale_provider')]);
$decoratedTaxonomyFactoryDefinition = new Definition($taxonomyFactoryClass);
$decoratedTaxonomyFactoryDefinition->setArguments([$translatableFactoryDefinition, new Reference('sylius.factory.taxon')]);
$container->setDefinition('sylius.factory.taxonomy', $decoratedTaxonomyFactoryDefinition);
$taxonFactoryDefinition = $container->getDefinition('sylius.factory.taxon');
$taxonFactoryClass = $taxonFactoryDefinition->getClass();
$taxonFactoryDefinition->setClass(TranslatableFactory::class);
$decoratedTaxonFactoryDefinition = new Definition($taxonFactoryClass);
$decoratedTaxonFactoryDefinition->addArgument($taxonFactoryDefinition)->addArgument(new Reference('sylius.repository.taxonomy'));
$container->setDefinition('sylius.factory.taxon', $decoratedTaxonFactoryDefinition);
}
/**
* Process the adaptor config configuration.
*
* @param array $config
* @param ContainerBuilder $container
*/
protected function loadConfigs(array $config, ContainerBuilder $container)
{
foreach ($config['configs'] as $name => $arguments) {
if (!$arguments['enabled']) {
continue;
}
$id = 'integrated_channel.config.memory.' . $name;
if ($container->hasDefinition($id)) {
continue;
}
// first create the options and for that we need a unique service id
do {
$id_options = $id . '.options.' . uniqid();
} while ($container->hasDefinition($id_options));
$definition = new Definition('%integrated_channel.config.options.class%');
$definition->setPublic(false);
$definition->setArguments([$arguments['options']]);
$container->setDefinition($id_options, $definition);
// create the config it self
$definition = new Definition('%integrated_channel.config.class%');
$definition->setArguments([$name, $arguments['adaptor'], new Reference($id_options)]);
if ($arguments['channel']) {
foreach ($arguments['channel'] as $channel) {
$definition->addTag('integrated_channel.config', ['channel' => $channel]);
}
} else {
$definition->addTag('integrated_channel.config');
}
$container->setDefinition($id, $definition);
}
}
/**
* {@inheritdoc}
*/
public function createDefinition(ContainerBuilder $container, array $config)
{
$definition = new Definition('Jose\\Object\\X5UJWKSet');
$definition->setFactory([new Reference('jose.factory.jwk'), 'createFromX5U']);
$definition->setArguments([$config['url'], $config['is_secured'], $config['cache'], $config['cache_ttl'], $config['is_https']]);
return $definition;
}
/**
* {@inheritdoc}
*/
public function createDefinition(ContainerBuilder $container, array $config)
{
$definition = new Definition('Jose\\Object\\JWK');
$definition->setFactory([new Reference('jose.factory.jwk'), 'createFromCertificate']);
$definition->setArguments([$config['value']]);
return $definition;
}
public function testProcessWithAddTemplates()
{
$container = $this->getContainer();
$layoutLoaderDef = new Definition(TwigLayoutLoader::class);
$mailLoaderDef = new Definition(TwigLayoutLoader::class);
$layoutLoaderDef->setArguments(array(array()));
$mailLoaderDef->setArguments(array(array()));
$container->setDefinition('sonatra_mailer.loader.layout_twig', $layoutLoaderDef);
$container->setDefinition('sonatra_mailer.loader.mail_twig', $mailLoaderDef);
$this->assertCount(0, $layoutLoaderDef->getArgument(0));
$this->assertCount(0, $mailLoaderDef->getArgument(0));
// array loader
$layoutArrayLoaderDef = new Definition(ArrayLayoutLoader::class);
$mailArrayLoaderDef = new Definition(ArrayLayoutLoader::class);
$layoutArrayLoaderDef->setArguments(array(array()));
$mailArrayLoaderDef->setArguments(array(array()));
$container->setDefinition('sonatra_mailer.loader.layout_array', $layoutArrayLoaderDef);
$container->setDefinition('sonatra_mailer.loader.mail_array', $mailArrayLoaderDef);
$this->assertCount(0, $layoutArrayLoaderDef->getArgument(0));
$this->assertCount(0, $mailArrayLoaderDef->getArgument(0));
// add mocks
$layoutLoaderDef->replaceArgument(0, array(array('name' => 'layout-test', 'file' => __DIR__ . '/../../Fixtures/loaders/layout.html.twig', 'translations' => array(array('locale' => 'fr', 'file' => __DIR__ . '/../../Fixtures/loaders/layout.fr.html.twig')))));
$mailLoaderDef->replaceArgument(0, array(array('name' => 'mail-test', 'file' => __DIR__ . '/../../Fixtures/loaders/mail.html.twig', 'layout' => 'layout-test', 'translations' => array(array('locale' => 'fr', 'file' => __DIR__ . '/../../Fixtures/loaders/mail.fr.html.twig')))));
// test
$this->pass->process($container);
$this->assertFalse($container->has('sonatra_mailer.loader.layout_twig'));
$this->assertFalse($container->has('sonatra_mailer.loader.mail_twig'));
}
/**
* {@inheritdoc}
*/
protected function addRepository(ContainerBuilder $container, MetadataInterface $metadata)
{
$reflection = new \ReflectionClass($metadata->getClass('model'));
$translatableInterface = 'Sylius\\Component\\Translation\\Model\\TranslatableInterface';
$translatable = interface_exists($translatableInterface) && $reflection->implementsInterface($translatableInterface);
$repositoryClassParameterName = sprintf('%s.repository.%s.class', $metadata->getApplicationName(), $metadata->getName());
$repositoryClass = $translatable ? 'Sylius\\Bundle\\TranslationBundle\\Doctrine\\ORM\\TranslatableResourceRepository' : 'Sylius\\Bundle\\ResourceBundle\\Doctrine\\ORM\\EntityRepository';
if ($container->hasParameter($repositoryClassParameterName)) {
$repositoryClass = $container->getParameter($repositoryClassParameterName);
}
if ($metadata->hasClass('repository')) {
$repositoryClass = $metadata->getClass('repository');
}
$definition = new Definition($repositoryClass);
$definition->setArguments(array(new Reference($metadata->getServiceId('manager')), $this->getClassMetadataDefinition($metadata)));
if ($metadata->hasParameter('translation')) {
$repositoryReflection = new \ReflectionClass($repositoryClass);
$translatableRepositoryInterface = 'Sylius\\Component\\Translation\\Repository\\TranslatableResourceRepositoryInterface';
$translationConfig = $metadata->getParameter('translation');
if (interface_exists($translatableRepositoryInterface) && $repositoryReflection->implementsInterface($translatableRepositoryInterface)) {
if (isset($translationConfig['fields'])) {
$definition->addMethodCall('setTranslatableFields', array($translationConfig['fields']));
}
}
}
$container->setDefinition($metadata->getServiceId('repository'), $definition);
}
/**
* {@inheritdoc}
*/
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');
foreach ($config['connections'] as $name => $values) {
$def = new Definition();
$def->setClass($container->getParameter('agentsib_sphinx.connection.class'));
$params = array('host' => $values['host'], 'port' => $values['port']);
if ($values['socket']) {
$params['socket'] = $values['socket'];
}
$def->setArguments(array($name, $values['driver'], $params));
$def->addMethodCall('addLogger', array(new Reference('agentsib_sphinx.logger')));
$container->setDefinition(sprintf('agentsib_sphinx.%s.connection', $name), $def);
$helperDef = new DefinitionDecorator('agentsib_sphinx.factory.helper');
$helperDef->setFactoryClass($container->getParameter('agentsib_sphinx.helper.class'));
$helperDef->setFactoryMethod('create');
$helperDef->addArgument(new Reference(sprintf('agentsib_sphinx.%s.connection', $name)));
$helperDef->setPublic(true);
$container->setDefinition(sprintf('agentsib_sphinx.%s.helper', $name), $helperDef);
if ($name == $config['default_connection']) {
$container->setAlias('agentsib_sphinx.connection', sprintf('agentsib_sphinx.%s.connection', $name));
$container->setAlias('agentsib_sphinx.helper', sprintf('agentsib_sphinx.%s.helper', $name));
}
}
}
/**
* Build the 'lexik_translation.translation_storage' service definition.
*
* @param ContainerBuilder $container
* @param string $storage
* @param string $objectManager
*/
protected function buildTranslationStorageDefinition(ContainerBuilder $container, $storage, $objectManager)
{
$container->setParameter('lexik_translation.storage.type', $storage);
if ('orm' == $storage) {
if (isset($objectManager)) {
$objectManagerReference = new Reference(sprintf('doctrine.orm.%s_entity_manager', $objectManager));
} else {
$objectManagerReference = new Reference('doctrine.orm.entity_manager');
}
} else {
if ('mongodb' == $storage) {
if (isset($objectManager)) {
$objectManagerReference = new Reference(sprintf('doctrine_mongodb.odm.%s_document_manager', $objectManager));
} else {
$objectManagerReference = new Reference('doctrine.odm.mongodb.document_manager');
}
} else {
if ('propel' == $storage) {
// In the Propel case the object_manager setting is used for the connection name
if (isset($objectManager)) {
$objectManagerReference = $objectManager;
} else {
$objectManagerReference = null;
}
} else {
throw new \RuntimeException(sprintf('Unsupported storage "%s".', $storage));
}
}
}
$storageDefinition = new Definition();
$storageDefinition->setClass(new Parameter(sprintf('lexik_translation.%s.translation_storage.class', $storage)));
$storageDefinition->setArguments(array($objectManagerReference, array('trans_unit' => new Parameter(sprintf('lexik_translation.%s.trans_unit.class', $storage)), 'translation' => new Parameter(sprintf('lexik_translation.%s.translation.class', $storage)), 'file' => new Parameter(sprintf('lexik_translation.%s.file.class', $storage)))));
$container->setDefinition('lexik_translation.translation_storage', $storageDefinition);
}
/**
* @inheritDoc
*/
public function createServiceDefinitions(array $data, ContainerBuilder $container, $prefix)
{
if (!isset($data['host'])) {
throw new UrlResolveException("No region hostname found in url");
}
if (!isset($data['user'])) {
throw new UrlResolveException("No key (username) found in url");
}
if (!isset($data['pass'])) {
throw new UrlResolveException("No secret (password) found in url");
}
if (!isset($data['clean_path'])) {
throw new UrlResolveException("No bucket name (path) found in url");
}
$region = $data['host'];
$key = $data['user'];
$secret = $data['pass'];
$bucket = $data['clean_path'];
$adapterPrefix = null;
if (isset($data['prefix'])) {
$adapterPrefix = $data['prefix'];
}
$version = 'latest';
if (isset($data['version'])) {
$version = $data['version'];
}
$client = new Definition('Aws\\S3\\S3Client');
$client->setFactory(['Aws\\S3\\S3Client', 'factory']);
$client->setArguments([['credentials' => ['key' => $key, 'secret' => $secret], 'region' => $region, 'version' => $version]]);
$container->setDefinition("{$prefix}.client", $client);
$container->setDefinition("{$prefix}.adapter", new Definition('League\\Flysystem\\AwsS3v3\\AwsS3Adapter', [new Reference("{$prefix}.client"), $bucket, $adapterPrefix]));
return "{$prefix}.adapter";
}
function it_processes_the_configuration_and_registers_services_per_variable(ContainerBuilder $container)
{
$variantFormType = new Definition('Some\\App\\Product\\Form\\ProductVariantType');
$variantFormType->setArguments(array('Some\\App\\Product\\Entity\\ProductVariant', '%sylius.validation_group.product_variant%', 'product'))->addTag('form.type', array('alias' => 'sylius_product_variant'));
$container->setDefinition('sylius.form.type.product_variant', $variantFormType)->shouldBeCalled();
$variantChoiceFormType = new Definition('Sylius\\Bundle\\VariationBundle\\Form\\Type\\VariantChoiceType');
$variantChoiceFormType->setArguments(array('product'))->addTag('form.type', array('alias' => 'sylius_product_variant_choice'));
$container->setDefinition('sylius.form.type.product_variant_choice', $variantChoiceFormType)->shouldBeCalled();
$variantMatchFormType = new Definition('Sylius\\Bundle\\VariationBundle\\Form\\Type\\VariantMatchType');
$variantMatchFormType->setArguments(array('product'))->addTag('form.type', array('alias' => 'sylius_product_variant_match'));
$container->setDefinition('sylius.form.type.product_variant_match', $variantMatchFormType)->shouldBeCalled();
$optionFormType = new Definition('Some\\App\\Product\\Form\\OptionType');
$optionFormType->setArguments(array('Some\\App\\Product\\Entity\\Option', '%sylius.validation_group.product_option%', 'product'))->addTag('form.type', array('alias' => 'sylius_product_option'));
$container->setDefinition('sylius.form.type.product_option', $optionFormType)->shouldBeCalled();
$optionChoiceFormType = new Definition('Sylius\\Bundle\\VariationBundle\\Form\\Type\\OptionEntityChoiceType');
$optionChoiceFormType->setArguments(array('product', 'Some\\App\\Product\\Entity\\Option'))->addTag('form.type', array('alias' => 'sylius_product_option_choice'));
$container->setDefinition('sylius.form.type.product_option_choice', $optionChoiceFormType)->shouldBeCalled();
$optionValueFormType = new Definition('Some\\App\\Product\\Form\\OptionValueType');
$optionValueFormType->setArguments(array('Some\\App\\Product\\Entity\\OptionValue', '%sylius.validation_group.product_option_value%', 'product'))->addTag('form.type', array('alias' => 'sylius_product_option_value'));
$container->setDefinition('sylius.form.type.product_option_value', $optionValueFormType)->shouldBeCalled();
$optionValueChoiceFormType = new Definition('Sylius\\Bundle\\VariationBundle\\Form\\Type\\OptionValueChoiceType');
$optionValueChoiceFormType->setArguments(array('product'))->addTag('form.type', array('alias' => 'sylius_product_option_value_choice'));
$container->setDefinition('sylius.form.type.product_option_value_choice', $optionValueChoiceFormType)->shouldBeCalled();
$optionValueCollectionFormType = new Definition('Sylius\\Bundle\\VariationBundle\\Form\\Type\\OptionValueCollectionType');
$optionValueCollectionFormType->setArguments(array('product'))->addTag('form.type', array('alias' => 'sylius_product_option_value_collection'));
$container->setDefinition('sylius.form.type.product_option_value_collection', $optionValueCollectionFormType)->shouldBeCalled();
$variables = array('product' => array('variable' => 'Some\\App\\Product\\Entity\\Product', 'option' => array('model' => 'Some\\App\\Product\\Entity\\Option', 'form' => 'Some\\App\\Product\\Form\\OptionType'), 'option_value' => array('model' => 'Some\\App\\Product\\Entity\\OptionValue', 'form' => 'Some\\App\\Product\\Form\\OptionValueType'), 'variant' => array('model' => 'Some\\App\\Product\\Entity\\ProductVariant', 'form' => 'Some\\App\\Product\\Form\\ProductVariantType')));
$container->setParameter('sylius.variation.variables', $variables)->shouldBeCalled();
$userConfig = array('driver' => SyliusResourceBundle::DRIVER_DOCTRINE_ORM, 'classes' => array('product' => array('variable' => 'Some\\App\\Product\\Entity\\Product', 'option' => array('model' => 'Some\\App\\Product\\Entity\\Option', 'form' => 'Some\\App\\Product\\Form\\OptionType'), 'option_value' => array('model' => 'Some\\App\\Product\\Entity\\OptionValue', 'form' => 'Some\\App\\Product\\Form\\OptionValueType'), 'variant' => array('model' => 'Some\\App\\Product\\Entity\\ProductVariant', 'form' => 'Some\\App\\Product\\Form\\ProductVariantType'))));
$processedConfig = array('driver' => SyliusResourceBundle::DRIVER_DOCTRINE_ORM, 'classes' => array('product_option' => array('model' => 'Some\\App\\Product\\Entity\\Option', 'form' => 'Some\\App\\Product\\Form\\OptionType'), 'product_option_value' => array('model' => 'Some\\App\\Product\\Entity\\OptionValue', 'form' => 'Some\\App\\Product\\Form\\OptionValueType'), 'product_variant' => array('model' => 'Some\\App\\Product\\Entity\\ProductVariant', 'form' => 'Some\\App\\Product\\Form\\ProductVariantType')), 'validation_groups' => array('product_variant' => array('sylius'), 'product_option' => array('sylius'), 'product_option_value' => array('sylius')));
$this->process($userConfig, $container)->shouldReturn($processedConfig);
}
/**
* {@inheritDoc}
*/
public function configure($name, array $config, Definition $service, ContainerBuilder $container)
{
$sqlite3Conf = $config['sqlite3'];
$tableName = $sqlite3Conf['table_name'];
$connectionRef = $this->getConnectionReference($name, $sqlite3Conf, $container);
$service->setArguments(array($connectionRef, $tableName));
}
private function convertFactoryDefinition(ContainerBuilder $container, $definition)
{
$symfonyDefinition = new Definition('Class');
$symfonyDefinition->setFactory([$this->convertArguments($container, $definition->getFactory()), $definition->getMethodName()]);
$symfonyDefinition->setArguments($this->convertArguments($container, $definition->getArguments()));
return $symfonyDefinition;
}
/**
* {@inheritdoc}
*/
public function createDefinition(ContainerBuilder $container, array $config)
{
$definition = new Definition('Jose\\Object\\StorableJWK');
$definition->setFactory([new Reference('jose.factory.jwk'), 'createStorableKey']);
$definition->setArguments([$config['storage_path'], $this->getKeyConfig($config)]);
return $definition;
}
public function load(array $configs, ContainerBuilder $container)
{
foreach ($configs as $config) {
if ($this->isConnectionConfig($config)) {
$connectionConfig = $config;
}
}
if ($container->hasParameter('connection_config')) {
$connectionConfig = $container->getParameter('connection_config');
}
$this->defineParameters($container);
$definition = new Definition('Symfony\\Component\\EventDispatcher\\ContainerAwareEventDispatcher');
$definition->setArguments(array(new Reference('service_container')));
$container->setDefinition('event_dispatcher', $definition);
$definition = new Definition('Rentgen\\Schema\\Manipulation');
$definition->setArguments(array(new Reference('service_container')));
$container->setDefinition('rentgen.schema.manipulation', $definition);
$definition = new Definition('Rentgen\\Schema\\Info');
$definition->setArguments(array(new Reference('service_container')));
$container->setDefinition('rentgen.schema.info', $definition);
if (!isset($connectionConfig)) {
$fileLocator = new FileLocator(getcwd());
try {
$configFile = $fileLocator->locate('rentgen.yml');
$content = file_get_contents('rentgen.yml');
$config = Yaml::parse($content);
$connectionConfig = $config;
} catch (\InvalidArgumentException $e) {
$connectionConfig['environments']['dev'] = array('adapter' => 'pgsql', 'host' => 'localhost', 'database' => null, 'username' => 'postgres', 'password' => '', 'port' => 5432);
}
}
$definition = new Definition('Rentgen\\Database\\Connection\\ConnectionConfig');
$definition->setArguments(array($connectionConfig['environments']));
$container->setDefinition('connection_config', $definition);
$definition = new Definition('Rentgen\\Database\\Connection\\Connection');
$definition->setArguments(array(new Reference('connection_config')));
$container->setDefinition('connection', $definition);
$this->connection = $container->getDefinition('connection');
$this->eventDispatcher = $container->getDefinition('event_dispatcher');
$this->setDefinition('rentgen.create_table', 'rentgen.command.manipulation.create_table.class', $container);
$this->setDefinition('rentgen.drop_table', 'rentgen.command.manipulation.drop_table.class', $container);
$this->setDefinition('rentgen.add_column', 'rentgen.command.manipulation.add_column.class', $container);
$this->setDefinition('rentgen.drop_column', 'rentgen.command.manipulation.drop_column.class', $container);
$this->setDefinition('rentgen.add_constraint', 'rentgen.command.manipulation.add_constraint.class', $container);
$this->setDefinition('rentgen.drop_constraint', 'rentgen.command.manipulation.drop_constraint.class', $container);
$this->setDefinition('rentgen.create_index', 'rentgen.command.manipulation.create_index.class', $container);
$this->setDefinition('rentgen.create_schema', 'rentgen.command.manipulation.create_schema.class', $container);
$this->setDefinition('rentgen.drop_schema', 'rentgen.command.manipulation.drop_schema.class', $container);
$this->setDefinition('rentgen.drop_index', 'rentgen.command.manipulation.drop_index.class', $container);
$this->setDefinition('rentgen.table_exists', 'rentgen.command.info.table_exists.class', $container);
$this->setDefinition('rentgen.get_table', 'rentgen.command.info.get_table.class', $container);
$this->setDefinition('rentgen.get_tables', 'rentgen.command.info.get_tables.class', $container);
$this->setDefinition('rentgen.get_schemas', 'rentgen.command.info.get_schemas.class', $container);
$this->setDefinition('rentgen.schema_exists', 'rentgen.command.info.schema_exists.class', $container);
$definition = new Definition($container->getParameter('rentgen.command.manipulation.clear_database.class'), array(new Reference('rentgen.get_schemas')));
$definition->addMethodCall('setConnection', array(new Reference('connection')));
$definition->addMethodCall('setEventDispatcher', array(new Reference('event_dispatcher')));
$container->setDefinition('rentgen.clear_database', $definition);
}
/**
* {@inheritdoc}
*/
protected function createFactoryDefinition(ContainerBuilder $container, $config)
{
$factoryClass = $config['factory'];
$modelClass = $config['model'];
$definition = new Definition($factoryClass);
$definition->setArguments([$modelClass]);
$container->setDefinition('swp.factory.' . $config['name'], $definition);
}
/**
* @param string $commandName
* @param array $commandOptions
*
* @return Definition
*/
private function generateCommandDefinition($commandName, array $commandOptions)
{
$commandOptions = $this->optionsResolver->resolve($commandOptions);
$definition = new Definition('PhpZone\\Docker\\Console\\Command\\DockerComposeCommand');
$definition->setArguments(array($commandName, $commandOptions, new Reference('phpzone.docker.script_builder.docker_compose')));
$definition->addTag('command');
return $definition;
}
/**
* {@inheritdoc}
*/
protected function addDefaultForm(ContainerBuilder $container, MetadataInterface $metadata)
{
$defaultFormBuilderDefinition = new Definition(DefaultFormBuilder::class);
$defaultFormBuilderDefinition->setArguments([new Reference($metadata->getServiceId('manager'))]);
$definition = new Definition(DefaultResourceType::class);
$definition->setArguments([$this->getMetdataDefinition($metadata), $defaultFormBuilderDefinition])->addTag('form.type', ['alias' => sprintf('%s_%s', $metadata->getApplicationName(), $metadata->getName())]);
$container->setDefinition(sprintf('%s.form.type.%s', $metadata->getApplicationName(), $metadata->getName()), $definition);
}
/**
* Build the listener that published messages to the queue.
*
* @param ContainerBuilder $container
* @param string $id
*
* @return void
*/
protected function addToEventBus(ContainerBuilder $container, $id)
{
$target = $container->getDefinition('broadway.event_handling.event_bus');
$definition = new Definition();
$definition->setClass('Simgroep\\EventSourcing\\EventHandling\\PublishMessageToQueue');
$definition->setArguments(array(new Reference($id)));
$target->addMethodCall('subscribe', array($definition));
}
/**
* @param string $commandName
* @param array $commandOptions
*
* @return Definition
*
* @throws MissingOptionsException
* @throws InvalidOptionsException
*/
private function generateCommandDefinition($commandName, array $commandOptions)
{
$resolvedCommandOptions = $this->optionsResolver->resolve($commandOptions);
$definition = new Definition('PhpZone\\Shell\\Console\\Command\\BatchScriptCommand');
$definition->setArguments(array($commandName, $resolvedCommandOptions));
$definition->addTag('command');
return $definition;
}
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;
}
protected function addProvider(ContainerBuilder $container, $providerClass, $modelName)
{
$providerReflection = new \ReflectionClass($providerClass);
$definition = new Definition($providerClass);
$definition->setArguments([new Reference(sprintf('%s.repository.%s', $this->applicationName, $modelName)), new Reference(sprintf('%s.factory.%s', $this->applicationName, $modelName))]);
$definition->setLazy(!$providerReflection->isFinal());
$container->setDefinition(sprintf('%s.provider.%s', $this->applicationName, $modelName), $definition);
}
function it_should_create_choice_form_definition(ContainerBuilder $container)
{
$this->mockDefaultBehavior($container);
$definition = new Definition('Sylius\\ChoiceFormType');
$definition->setArguments(array('Sylius\\Model', SyliusResourceBundle::DRIVER_DOCTRINE_PHPCR_ODM, 'sylius_resource_choice'))->addTag('form.type', array('alias' => 'sylius_resource_choice'));
$container->setDefinition('sylius.form.type.resource_choice', Argument::exact($definition))->shouldBeCalled();
$this->configure(array('sylius' => array('driver' => SyliusResourceBundle::DRIVER_DOCTRINE_PHPCR_ODM, 'classes' => array('resource' => array('form' => array('choice' => 'Sylius\\ChoiceFormType'))))), new Configuration(), $container, AbstractResourceExtension::CONFIGURE_FORMS);
}
public function it_should_process(ContainerBuilder $c, Definition $definition)
{
$c->findTaggedServiceIds('hector.publisher')->shouldBeCalled()->willReturn(['publisher' => [['routing_key_prefix' => 'foo', 'exchange' => 'bar']]]);
$definition->setFactory([new Reference('hector.publisher.factory'), 'create'])->shouldBeCalled();
$definition->setArguments(['default', 'bar', null, ['routing_key_prefix' => 'foo']])->shouldBeCalled();
$c->getDefinition('publisher')->shouldBeCalled()->willReturn($definition);
$this->process($c);
}
private function buildServiceProxyFactoryDefinition($taggedServiceName, $tagParameters)
{
$definition = $this->container->findDefinition($taggedServiceName);
$factoryDefinition = new Definition();
$factoryDefinition->setFactory([new Reference('openclassrooms.service_proxy.service_proxy_factory'), 'create']);
$factoryDefinition->setArguments([$definition, $tagParameters[0]]);
$this->container->setDefinition($taggedServiceName, $factoryDefinition);
}
/**
* {@inheritdoc}
*/
protected function processReferences($connectionServiceId, array $referencesConfig, ContainerBuilder $container)
{
foreach ($referencesConfig as $key => $value) {
$referenceDefinition = new Definition();
$referenceDefinition->setClass('Kreait\\Firebase\\Reference');
$referenceDefinition->setArguments(array(new Reference($connectionServiceId), $value));
$container->setDefinition('kreait_firebase.reference.' . $key, $referenceDefinition);
}
}
