private function setNormalizers()
{
$this->resolver->setNormalizers([self::CHARSETS => function (Options $options, $value) {
$value = array_map('strtoupper', $value);
$value = $this->replaceWin1250WithIso($value);
$value = $this->filterSupportedCharsets($value);
$value = $this->moveUtfFirst($value);
return $value;
}]);
}
private function setNormalizers()
{
$this->resolver->setNormalizers([TCO::RESOURCES => function (Options $options, $resources) {
$absolutizedResources = [];
foreach ($resources as $key => $resource) {
$key = $options['templatesPath'] . '/' . $key;
$absolutizedResources[$key] = $resource;
}
return $absolutizedResources;
}, TCO::TEMPLATES => function (Options $options, $value) {
return $this->makeTemplatePathsAbsolute($value, $options);
}]);
}
/**
* Options:
* - grid_widget_route - route of widget where selection grid will be rendered
* - grid_name - name of grid that will be used for entity selection
* - grid_parameters - parameters need to be passed to grid request
* - grid_render_parameters - render parameters need to be set for grid rendering
* - existing_entity_grid_id - grid row field name used as entity identifier
* - create_enabled - enables new entity creation
* - create_acl - ACL resource used to determine that create is allowed, by default CREATE for entity used
* - create_form_route - route name for creation form
* - create_form_route_parameters - route parameters for create_form_route_parameters
*
* {@inheritDoc}
*/
public function configureOptions(OptionsResolver $resolver)
{
$resolver->setDefaults(['existing_entity_grid_id' => 'id', 'create_enabled' => true, 'create_acl' => null, 'create_form_route' => null, 'create_form_route_parameters' => [], 'grid_widget_route' => 'oro_datagrid_widget', 'grid_name' => null, 'grid_parameters' => [], 'grid_render_parameters' => []]);
$resolver->setNormalizers(['create_enabled' => function (Options $options, $createEnabled) {
$createRouteName = $options->get('create_form_route');
$createEnabled = $createEnabled && !empty($createRouteName);
if ($createEnabled) {
$aclName = $options->get('create_acl');
if (empty($aclName)) {
$aclObjectName = 'Entity:' . $options->get('entity_class');
$createEnabled = $this->securityFacade->isGranted('CREATE', $aclObjectName);
} else {
$createEnabled = $this->securityFacade->isGranted($aclName);
}
}
return $createEnabled;
}, 'grid_name' => function (Options $options, $gridName) {
if (!empty($gridName)) {
return $gridName;
}
$formConfig = $this->configManager->getProvider('form')->getConfig($options->get('entity_class'));
if ($formConfig->has('grid_name')) {
return $formConfig->get('grid_name');
}
throw new InvalidConfigurationException('The option "grid_name" must be set.');
}]);
}
private function setNormalizers()
{
$this->resolver->setNormalizers([CO::ANNOTATION_GROUPS => function (Options $options, $value) {
$value = (array) $value;
if ($options[CO::DEPRECATED]) {
$value[] = CO::DEPRECATED;
}
if ($options[CO::TODO]) {
$value[] = CO::TODO;
}
return array_unique($value);
}, CO::DESTINATION => function (Options $options, $value) {
return FileSystem::getAbsolutePath($value);
}, CO::BASE_URL => function (Options $options, $value) {
return rtrim($value, '/');
}, CO::SKIP_DOC_PATH => function (Options $options, $value) {
$value = (array) $value;
foreach ($value as $key => $source) {
$value[$key] = FileSystem::getAbsolutePath($source);
}
return $value;
}, CO::SOURCE => function (Options $options, $value) {
if (!is_array($value)) {
$value = [$value];
}
foreach ($value as $key => $source) {
$value[$key] = FileSystem::getAbsolutePath($source);
}
return $value;
}, CO::SOURCE_CODE => function (Options $options) {
return !$options[CO::NO_SOURCE_CODE];
}, CO::TEMPLATE_CONFIG => function (Options $options, $value) {
return FileSystem::getAbsolutePath($value);
}]);
}
/**
* {@inheritdoc}
*/
public function configureOptions(OptionsResolver $resolver)
{
$resolver->setDefaults(['field' => 'string', 'type' => 'text', 'options' => [], 'allow_add' => true, 'allow_delete' => true]);
$resolver->setNormalizers(['type' => function () {
return new StubLocalizedFallbackValueType();
}, 'options' => function () {
return [];
}]);
}
public function setNormalizers(array $normalizers)
{
if (!$this->isLatest()) {
return parent::setNormalizers($normalizers);
}
foreach ($normalizers as $option => $normalizer) {
parent::setNormalizer($option, $normalizer);
}
return $this;
}
public function testNormalizersTransformFinalOptions()
{
$this->resolver->setDefaults(array('foo' => 'bar', 'bam' => 'baz'));
$this->resolver->setNormalizers(array('foo' => function (Options $options, $value) {
return $options['bam'] . '[' . $value . ']';
}));
$expected = array('foo' => 'baz[bar]', 'bam' => 'baz');
$this->assertEquals($expected, $this->resolver->resolve(array()));
$expected = array('foo' => 'boo[custom]', 'bam' => 'boo');
$this->assertEquals($expected, $this->resolver->resolve(array('foo' => 'custom', 'bam' => 'boo')));
}
public function configureOptions(OptionsResolver $resolver)
{
$addTypeConstraint = function ($options, $value) {
// Constraint should always be converted to an array
$value = is_object($value) ? array($value) : (array) $value;
$value[] = new IpAddress();
return $value;
};
$resolver->setDefaults(array('placeholder' => '192.0.2.193, *.example.com, ...'));
$resolver->setNormalizers(array('constraints' => $addTypeConstraint));
}
/**
* {@inheritdoc}
*/
public function configureOptions(OptionsResolver $resolver)
{
$resolver->setDefaults(array('number' => 5, 'configs' => array(), 'expanded' => true, 'choices' => function (Options $options) {
$choices = array();
for ($i = 1; $i <= $options['number']; $i++) {
$choices[$i] = null;
}
return $choices;
}));
$resolver->setNormalizers(array('expanded' => function (Options $options, $value) {
return true;
}));
}
protected function configureOptions(OptionsResolver $resolver)
{
$resolver->setDefaults(['extension' => 'stockpile', 'directory' => sys_get_temp_dir() . '/stockpile']);
$resolver->setRequired(['directory']);
$resolver->setNormalizers(['extension' => function (Options $options, $extension) {
$extension = Driver::normalizeKey($extension);
$extension = strtolower($extension);
$extension = trim($extension, '.');
return '.' . $extension;
}, 'directory' => function (Options $options, $directory) {
return self::normalizeKey($directory);
}]);
}
/**
* {@inheritdoc}
*/
public function configureOptions(OptionsResolver $resolver)
{
$configurator = $this->configurator;
$resolver->setDefaults(array('allow_extra_fields' => true, 'data_class' => function (Options $options) use($configurator) {
$entity = $options['entity'];
$entityConfig = $configurator->getEntityConfiguration($entity);
return $entityConfig['class'];
}))->setRequired(array('entity', 'view'));
if ($this->useLegacyFormComponent()) {
$resolver->setNormalizers(array('attr' => $this->getAttributesNormalizer()));
} else {
$resolver->setNormalizer('attr', $this->getAttributesNormalizer());
}
}
/**
* @param StateMachineInterface $stateMachine
*/
private function loadTransitions(StateMachineInterface $stateMachine)
{
$resolver = new OptionsResolver();
$resolver->setRequired(array('from', 'to'));
$resolver->setOptional(array('guard'));
$resolver->setNormalizers(array('from' => function (Options $options, $v) {
return (array) $v;
}, 'guard' => function (Options $options, $v) {
return !isset($v) ? null : $v;
}));
foreach ($this->config['transitions'] as $transition => $config) {
$config = $resolver->resolve($config);
$stateMachine->addTransition(new Transition($transition, $config['from'], $config['to'], $config['guard']));
}
}
public function configureOptionsResolver(OptionsResolver $resolver)
{
$allowedProfileTypes = array('Giftcards\\Encryption\\Profile\\Profile');
$resolver->setRequired(array('profile'));
if ($this->profileRegistry) {
$allowedProfileTypes[] = 'string';
$profileRegistry = $this->profileRegistry;
$resolver->setNormalizers(array('profile' => function ($_, $profile) use($profileRegistry) {
if ($profile instanceof Profile) {
return $profile;
}
return $profileRegistry->get((string) $profile);
}));
}
$resolver->setAllowedTypes(array('profile' => $allowedProfileTypes));
}
/**
* {@inheritdoc}
*/
public function configureOptions(OptionsResolver $resolver)
{
$resolver->setDefaults(array('data_class' => null, 'multiple' => true, 'render_label' => false, 'model_transformer' => 'Sylius\\Bundle\\TaxonomyBundle\\Form\\DataTransformer\\TaxonSelectionToCollectionTransformer'));
$resolver->setNormalizers(array('model_transformer' => function (Options $options, $value) {
if (!is_array($value)) {
$value = array('class' => $value, 'save_objects' => true);
} else {
if (!isset($value['class'])) {
$value['class'] = 'Sylius\\Bundle\\TaxonomyBundle\\Form\\DataTransformer\\TaxonSelectionToCollectionTransformer';
}
if (!isset($value['save_objects'])) {
$value['save_objects'] = true;
}
}
return $value;
}));
}
/**
* @param OptionsResolver $resolver
* @param string $integrationType
*/
protected function setUpResolver(OptionsResolver $resolver, $integrationType)
{
$defined = array();
$defaults = array();
$options = $this->getOptions();
foreach ($options as $name => $option) {
if ($integrationType && !empty($option['for types']) && !in_array($integrationType, $option['for types'])) {
unset($options[$name]);
continue;
}
if (!empty($option['default'])) {
$defaults[$name] = $option['default'];
} else {
$defined[] = $name;
}
}
$resolver->setDefined($defined);
$resolver->setDefaults($defaults);
$required = array();
$normalizers = array();
foreach ($options as $name => $option) {
if (!empty($option['required']) && (empty($option['for types']) || $integrationType)) {
$required[] = $name;
}
if (!empty($option['normalizer'])) {
$normalizers[$name] = $option['normalizer'];
}
if (!empty($option['type'])) {
$resolver->setAllowedTypes($name, $option['type']);
}
if (!empty($option['validator'])) {
$resolver->setAllowedValues($name, $option['validator']);
} elseif (!empty($option['options'])) {
$resolver->setAllowedValues($name, $option['options']);
}
}
$resolver->setRequired($required);
$resolver->setNormalizers($normalizers);
}
/**
* @return OptionsResolverInterface
*/
protected function createOptionsResolver()
{
$resolver = new OptionsResolver();
$required = [];
$allowedTypes = ['family' => 'string', 'enabled' => 'bool', 'categories' => 'string', 'groups' => 'string'];
$optional = array_merge(['family', 'enabled', 'categories', 'groups'], $this->attrColumnsResolver->resolveAttributeColumns(), $this->getOptionalAssociationFields());
$resolver->setRequired($required);
$resolver->setOptional($optional);
$resolver->setAllowedTypes($allowedTypes);
$booleanNormalizer = function ($options, $value) {
return (bool) $value;
};
$resolver->setNormalizers(['enabled' => $booleanNormalizer]);
return $resolver;
}
/**
* @param ListingTypeInterface $type
* @param array $options
* @return Listing
*/
public function createListing(ListingTypeInterface $type, array $options = array())
{
$router = $this->renderer->getRouter();
$dataSourceResolver = function (Options $options) use($router) {
if (isset($options['route'])) {
$data_source = $router->generate($options['route'], isset($options['route_parameters']) ? $options['route_parameters'] : array());
} else {
$data_source = $options['request']->getRequestUri();
}
return $data_source;
};
$pageLengthMenuOptionsNormalizer = function (Options $options, $value) {
$lengthMenu = array();
foreach ($value as $length) {
$lengthMenu[0][] = $length > 0 ? (int) $length : -1;
$lengthMenu[1][] = $length > 0 ? (int) $length : '-';
}
/*
// Ensure that "page_length" option is in "page_length_menu" array:
if (!isset($lengthMenu[0][0]) || !in_array((int)$options['page_length'], $lengthMenu[0])) {
$lengthMenu[0][] = $options['page_length'] > 0 ? (int)$options['page_length'] : -1;
$lengthMenu[1][] = $options['page_length'] > 0 ? (int)$options['page_length'] : '-';
}
*/
return $lengthMenu;
};
$columnBuilder = $this->createColumnBuilder($type, $options);
$filterBuilder = $this->createFilterBuilder($type, $options);
// Load default options to resolver:
$optionsResolver = new OptionsResolver();
$optionsResolver->setRequired(array('request'));
$optionsResolver->setDefined(array('template', 'class', 'query_builder', 'process_result_callback', 'process_row_callback', 'order_by', 'order_direction', 'order_column'));
$optionsResolver->setDefaults(array('data_source' => $dataSourceResolver, 'page_length' => 10, 'page_length_menu' => array(10, 25, 50, 100, -1), 'auto_width' => true, 'row_attr' => array('id' => $this->defaultIdProperty ?: null, 'class' => null), 'order_column' => array(), 'save_state' => false, 'defer_load' => false));
$optionsResolver->setNormalizers(array('page_length_menu' => $pageLengthMenuOptionsNormalizer));
// Modify default options by ListingType:
$type->setDefaultOptions($optionsResolver);
$listing = new Listing($type->getName(), $columnBuilder->getColumns(), $filterBuilder->getFilters(), $this->registry, $this->eventDispatcher, $this->renderer, $optionsResolver->resolve($options));
return $listing;
}
/**
* {@inheritdoc}
*/
public function configureOptions(OptionsResolver $resolver)
{
$type = $this->type;
$registry = $this->registry;
$resolver->setDefaults(array('configs' => array(), 'suggestions' => array(), 'route_name' => null, 'class' => null, 'property' => null, 'em' => null, 'document_manager' => null));
$resolver->setNormalizers(array('em' => function (Options $options, $manager) use($registry, $type) {
if (!in_array($type, array('entity', 'document'))) {
return null;
}
if (null !== $options['document_manager'] && $manager) {
throw new \InvalidArgumentException('You cannot set both an "em" and "document_manager" option.');
}
$manager = $options['document_manager'] ?: $manager;
if (null === $manager) {
return $registry->getManagerForClass($options['class']);
}
return $registry->getManager($manager);
}, 'suggestions' => function (Options $options, $suggestions) use($type, $registry) {
if (null !== $options['route_name']) {
return array();
}
if (empty($suggestions)) {
switch ($type) {
case 'entity':
case 'document':
$propertyPath = $options['property'] ? new PropertyPath($options['property']) : null;
$suggestions = array();
$objects = $options['em']->getRepository($options['class'])->findAll();
foreach ($objects as $object) {
if ($propertyPath) {
$suggestions[] = PropertyAccess::createPropertyAccessor()->getValue($object, $propertyPath);
} elseif (method_exists($object, '__toString')) {
$suggestions[] = (string) $object;
} else {
throw new \RuntimeException(sprintf('Cannot cast object of type "%s" to string, ' . 'please implement a __toString method or ' . 'set the "property" option to the desired value.', get_class($object)));
}
}
break;
}
}
return $suggestions;
}));
}
function it_has_options(OptionsResolver $resolver)
{
$resolver->setDefaults(array('data_class' => null, 'multiple' => true, 'render_label' => false, 'model_transformer' => TaxonSelectionToCollectionTransformer::class))->shouldBeCalled();
$resolver->setNormalizers(Argument::withKey('model_transformer'))->shouldBeCalled();
$this->configureOptions($resolver);
}
/**
* {@inheritdoc}
*/
public function configureOptions(OptionsResolver $resolver)
{
$compound = function (Options $options) {
return $options['widget'] !== 'single_text';
};
$emptyValue = $emptyValueDefault = function (Options $options) {
return $options['required'] ? null : '';
};
// for BC with the "empty_value" option
$placeholder = function (Options $options) {
return $options['empty_value'];
};
$emptyValueNormalizer = function (Options $options, $emptyValue) use($emptyValueDefault) {
if (is_array($emptyValue)) {
$default = $emptyValueDefault($options);
return array_merge(array('hour' => $default, 'minute' => $default, 'second' => $default), $emptyValue);
}
return array('hour' => $emptyValue, 'minute' => $emptyValue, 'second' => $emptyValue);
};
$preferredChoicesNormalizer = function (Options $options, $preferredChoices) {
if (is_array($preferredChoices)) {
$default = array();
return array_merge(array('hours' => $default, 'minutes' => $default, 'seconds' => $default), $preferredChoices);
}
return array('hours' => $default, 'minutes' => $default, 'seconds' => $default);
};
$resolver->setDefaults(array('hours' => range(0, 23), 'minutes' => range(0, 59), 'seconds' => range(0, 59), 'widget' => 'choice', 'input' => 'datetime', 'preferred_choices' => array(), 'with_minutes' => true, 'with_seconds' => false, 'model_timezone' => null, 'view_timezone' => null, 'empty_value' => $emptyValue, 'placeholder' => $placeholder, 'html5' => true, 'by_reference' => false, 'error_bubbling' => false, 'data_class' => null, 'compound' => $compound));
$resolver->setNormalizers(array('empty_value' => $emptyValueNormalizer, 'preferred_choices' => $preferredChoicesNormalizer));
$resolver->setAllowedValues(array('input' => array('datetime', 'string', 'timestamp', 'array'), 'widget' => array('single_text', 'text', 'choice')));
}
